baptisterajaut/radmin-vpn-linuxExecute Radmin VPN no Linux via Wine — driver personalizado, ponte TAP, zero perda de pacotes
# Radmin VPN para Linux
Execute o [Radmin VPN](https://www.radmin-vpn.com/) no Linux via Wine. Entre em redes VPN, veja peers, jogue — tudo sem uma VM Windows.
> Não construí isto porque era mais fácil que uma VM. Construí porque pensei que era mais fácil que uma VM.
**Código assistido por IA.** Construído colaborativamente entre um humano e Claude (Anthropic). O driver, os hooks e a ponte foram escritos com engenharia reversa extensivamente assistida por IA do protocolo de driver não documentado do Radmin VPN usando Ghidra. **Isto funciona, mas não oferece garantias.** Não afiliado à Famatech. O Radmin VPN é proprietário — baixe-o você mesmo em [radmin-vpn.com](https://www.radmin-vpn.com/). Use por sua conta e risco.
## Como funciona
O serviço Windows do Radmin VPN comunica-se com um driver miniport NDIS para seu adaptador de rede virtual. O Wine não suporta NDIS, então substituímos o driver por nossa própria implementação que faz a ponte para um dispositivo TAP Linux. Uma DLL de hook lida com problemas de compatibilidade do Wine (nomenclatura de adaptador, permissões de registro). O resultado é um cliente Radmin VPN totalmente funcional rodando nativamente sob o Wine.
```
Aplicativo Linux ← TAP (radminvpn0) ← tap_bridge ← FIFO ← rvpnnetmp.sys (driver Wine) ← RvControlSvc.exe
```
## Início rápido (AppImage, recomendado)
Pegue o `RadminVPN-Linux-x86_64.AppImage` na [última versão](https://github.com/baptisterajaut/radmin-vpn-linux/releases/latest). Nada para instalar — o Wine está incluído.
> **Candidatos a versão** (ex.: `v1.0.0-rc1`) são publicados como *pré-lançamentos* do GitHub. O link `latest` acima sempre aponta para a build *estável* mais recente, então pré-lançamentos não aparecerão lá — pegue-os na [lista completa de versões](https://github.com/baptisterajaut/radmin-vpn-linux/releases).
```bash
chmod +x RadminVPN-Linux-x86_64.AppImage
./RadminVPN-Linux-x86_64.AppImage
```
No primeiro início, ele baixa o instalador do Radmin VPN contra o qual é validado (ou passe o seu próprio com `--installer`). Um terminal abre com o progresso, e um prompt de senha sudo é necessário para a configuração do TAP.
O estado persistente (wineprefix, MAC, logs) fica em `~/.local/share/radmin-vpn-linux/`.
> **O Radmin fechando sozinho?** O próprio atualizador dele está instalando uma build mais nova dentro do prefixo
> em execução. Faça a atualização de forma controlada — ela mantém seu prefixo e seu ID Radmin:
> ```bash
> ./RadminVPN-Linux-x86_64.AppImage --update
> ```
> Depois desative "Atualizações automáticas" nas configurações do Radmin para que ele pare de tentar. Detalhes em
> [atualizador automático do próprio Radmin](#atualizador-automático-do-próprio-radmin).
## Pré-requisitos (build de fonte / não-AppImage)
- **Wine** >= 11.0 (testado no Wine 11.5 Arch Linux e no Wine 11.6 Ubuntu 24.04)
- **mingw-w64** compiladores cruzados (`i686-w64-mingw32-gcc`, `x86_64-w64-mingw32-gcc`) — para compilar a partir da fonte
- **iconv** (glibc) — para análise de logs do serviço
- Acesso **sudo** — para criação do dispositivo TAP e roteamento
- **Suporte a TUN/TAP no kernel** — geralmente embutido, verifique com `modprobe tun`
- **Instalador do Radmin VPN** — baixado automaticamente se ausente. A versão contra a qual este projeto é validado está fixada em um único lugar, `RADMIN_VERSION` em `lib.sh` (atualmente **2.1.4951.1**; 2.0.4899.9 também funciona). O Radmin VPN **1.4 não é suportado** — ele registra e abre o adaptador, mas nunca termina a conexão sob o shim do Wine, deixando a GUI presa em "Conectando...".
### Arch Linux
```bash
sudo pacman -S wine mingw-w64-gcc
```
### Ubuntu/Debian
```bash
sudo apt install wine64 wine32 gcc-mingw-w64
```
## Início rápido pela fonte
```bash
git clone https://github.com/baptisterajaut/radmin-vpn-linux.git
cd radmin-vpn-linux
# Opção A: baixar binários pré-compilados das Releases do GitHub
mkdir -p build
TAG=$(curl -sI https://github.com/baptisterajaut/radmin-vpn-linux/releases/latest | grep -i location | grep -oP 'v[\d.]+')
curl -sL "https://github.com/baptisterajaut/radmin-vpn-linux/releases/download/${TAG}/radmin-vpn-linux-${TAG}.tar.gz" \
| tar xz -C build/
# Opção B: compilar a partir da fonte
make
# Baixe o instalador do Radmin VPN de https://www.radmin-vpn.com/
./run.sh --installer ~/Downloads/Radmin_VPN_*.exe
```
Em execuções subsequentes, basta:
```bash
./run.sh
```
### Flags de linha de comando
| Flag | Descrição |
|------|-------------|
| `--installer <caminho>` | Caminho para o instalador `Radmin_VPN_*.exe` (apenas na primeira execução). |
| `--no-ui` | Executa o serviço sem iniciar a GUI do Radmin. |
| `--update` | Atualiza o Radmin para a versão fixada no lugar. Mantém o prefixo, então o RID registrado na Famatech sobrevive. |
| `--no-broadcast-routes` | Não adiciona as rotas de broadcast/multicast → TAP. |
| `--filter-ui` | Inicia a UI opcional de filtro de pacotes GTK4 (desativada por padrão). |
| `--fix-chat` | Aplica patch no `qwindows.dll` do Qt para corrigir o crash da janela de chat sob o Wine (desativado por padrão). |
### Atualizador automático do próprio Radmin
A GUI do Radmin pode baixar uma build mais nova e executar seu instalador *dentro do prefixo ativo*,
o que mata a GUI e causa falha no serviço em execução (o log da GUI então mostra um instalador
sob `AppData\\Local\\Temp`). Duas defesas: o launcher fornece a build validada atual
para que o atualizador não tenha nada para enviar, e uma GUI que morre não leva mais o túnel
junto — ela é reiniciada uma vez, e então a VPN continua rodando sem cabeça. Para atualizar
deliberadamente, use `./run.sh --update`, que para tudo primeiro. Desativar
"Atualizações automáticas" nas configurações da GUI evita a corrida por completo.
Tanto `--filter-ui` quanto `--fix-chat` são opcionais. A UI de filtro precisa do binário `rvpn_filter_ui`
(compilado pelo `make`); a correção do chat precisa de `patch_qwindows_font.py` e um interpretador Python 3.
## Modos sem cabeça / servidor
Dois launchers extras executam o Radmin VPN sem um desktop local — para um VPS ou host de datacenter. Ambos instalam e configuram exatamente como o `run.sh` (mesmo wineprefix, mesmo fluxo de primeira execução com `--installer`, mesma ponte TAP); eles diferem apenas em como a GUI é acessada.
### `run_datacenter.sh` — GUI pelo navegador
Executa a GUI real do Radmin em um display virtual (Xvfb) e a serve via VNC + noVNC, para que você possa configurar suas redes pelo navegador e depois deixá-la rodando.
```bash
sudo apt install -y xvfb x11vnc websockify novnc # ou: make install-datacenter-deps
./run_datacenter.sh --installer ~/Downloads/Radmin_VPN_*.exe
```
| Flag | Padrão | Descrição |
|------|---------|-------------|
| `--vnc-port <n>` | `5900` | Porta para o servidor x11vnc. |
| `--web-port <n>` | `6080` | Porta para o endpoint web noVNC. |
| `--vnc-password <senha>` | *(nenhuma)* | Senha para a sessão VNC / web. |
| `--web-bind <endereço>` | `127.0.0.1` | Endereço no qual o noVNC escuta. |
Por padrão, o noVNC vincula-se a `127.0.0.1`, então só é acessível através de um túnel SSH:
```bash
ssh -L 6080:localhost:6080 seu-vps # depois abra http://localhost:6080/vnc.html
```
Para expô-lo publicamente, passe `--web-bind 0.0.0.0` **junto com** `--vnc-password` — caso contrário, qualquer pessoa que alcance a porta web cairá em um desktop não autenticado com capacidade de root. O script imprime um aviso bem alto se você vincular publicamente sem senha.
### `run_vps.sh` — apenas serviço, GUID fixo
Inicia o serviço sem cabeça com um GUID TAP fixo (sem necessidade de WMI do Wine) e sem GUI alguma. Se um enumerador de rede personalizado (`rv_net_enum.exe`, não incluído neste repositório) estiver presente um diretório acima, ele é iniciado; caso contrário, o serviço apenas roda até você pressionar Ctrl+C. Apenas `--installer` é aceito.
```bash
./run_vps.sh --installer ~/Downloads/Radmin_VPN_*.exe
```
## Compilando a partir da fonte
Requer compiladores cruzados `mingw-w64`. Binários pré-compilados estão disponíveis nas [Releases](https://github.com/baptisterajaut/radmin-vpn-linux/releases) (compilados pela CI em cada versão marcada) se você não quiser instalar o mingw.
```bash
make # compila tudo para build/
make clean # remove artefatos de build
```
Produz:
- `build/rvpnnetmp.sys` — driver de kernel Wine (PE 64 bits)
- `build/adapter_hook.dll` — DLL de hook (PE 32 bits)
- `build/rvpn_launcher.exe` — injetor de DLL (PE 32 bits)
- `build/netsh.exe` — substituto do netsh (PE 32 bits, instalado em SysWOW64)
- `build/netsh64.exe` — substituto do netsh (PE 64 bits, instalado em System32)
- `build/drvinst.exe` — stub sem operação substituindo o instalador real do driver NDIS do Radmin (issue #12)
- `build/tap_bridge` — ponte TAP Linux nativa
- `build/rvpn_dnsfix.so` — shim nativo LD_PRELOAD, pré-carregado apenas no serviço
- `build/rvpn_reuseport.so` — shim nativo LD_PRELOAD, pré-carregado no `wineserver`
- `build/rvpn_filter_ui` — UI opcional de filtro de pacotes GTK4 (`--filter-ui`)
### Compilando o AppImage
```bash
make
./packaging/build-appimage.sh # → packaging/dist/RadminVPN-Linux-x86_64.AppImage
```
Baixa a build Wine-Staging `amd64-wow64` do Kron4ek (~100 MB) e o `appimagetool` na primeira execução, armazenando ambos em cache em `packaging/dist/`. Requer `curl` e ImageMagick (`convert`).
## O que o `run.sh` faz
1. **Primeira execução**: instala o Radmin VPN via Wine (`/VERYSILENT`), remove o driver NDIS real (incompatível com o Wine), registra nosso driver personalizado
2. **Toda execução**: cria um dispositivo TAP, inicia a ponte TAP-para-FIFO, configura o registro do Wine (GUID do adaptador, serviço de driver), inicia o serviço e a GUI do Radmin VPN
3. **Na saída** (Ctrl+C ou fechar a GUI): mata o Wine, remove o dispositivo TAP, limpa
O wineprefix é armazenado em `./wineprefix/` (execução pela fonte) ou `~/.local/share/radmin-vpn-linux/wineprefix/` (AppImage). Um endereço MAC persistente é gerado na primeira execução e salvo no wineprefix.
## Arquitetura
| Componente | Descrição |
|---|---|
| `rvpnnetmp.sys` | Driver de kernel Wine. Emula o miniport NDIS do Radmin. Lida com IOCTLs (VERSION, STATUS, SETUP, PEERMAC), codificação/decodificação de quadros TLV, fila de IRP para I/O sobreposto, roteamento de quadros baseado em MAC para suporte a múltiplos peers. |
| `adapter_hook.dll` | DLL companheira carregada junto com o RvControlSvc.exe. Hooks de IAT: renomeia o adaptador TAP para corresponder ao nome esperado pelo Radmin, anula `RegSetKeySecurity` para contornar um bug do SCM do Wine onde serviços não recebem o SID SYSTEM, e responde às quatro buscas `Perf{Increment,Decrement}ULong{,Long}CounterValue` que o `advapi32` do Wine não exporta. Essa última não é cosmética: o Radmin 2.1 resolve sete pontos de entrada do perflib em uma cascata de tudo-ou-nada, depois passa o objeto de contador por-peer resultante como o payload do handshake de peer — então quatro exports de telemetria ausentes derrubam todo o caminho de dados (issue #24, `docs/wine-perflib.md`). |
| `tap_bridge` | Binário Linux nativo. Retransmite quadros ethernet entre o dispositivo TAP e pipes nomeados (FIFOs) que o driver Wine lê/escreve. |
| `netsh.exe` / `netsh64.exe` | Substitui o stub do netsh do Wine (32 bits em SysWOW64, 64 bits em System32). Traduz comandos Windows `netsh interface ip` para comandos Linux `ip addr`/`ip link` via um relay baseado em arquivo, validando o endereço antes que ele alcance o relay root. |
| `rvpn_launcher.exe` | Injeta `adapter_hook.dll` no processo do serviço Radmin via `CreateRemoteThread` + `LoadLibrary`. |
| `drvinst.exe` | Stub sem operação substituindo o instalador real do driver NDIS do Radmin. O Radmin o executa em tempo de execução para carregar `NetMP60_1_1_64.sys`, que aborta o Wine 11.x via `NdisInitializeReadWriteLock` (issue #12); como nosso driver já substitui esse adaptador, o real nunca deve carregar. |
| `rvpn_dnsfix.so` | Shim nativo `LD_PRELOAD`, injetado apenas no início do serviço. Contorna o DNS reverso (`getnameinfo`/`gethostbyaddr`) de IPv4/IPv6 privados na camada glibc. O Radmin faz resolução PTR de cada endereço candidato local que coleta; em um host cujo resolvedor bloqueia consultas PTR RFC1918, isso trava por minutos e o serviço registra mas nunca fica pronto (issue #16). A consulta é emitida pelo lado Unix do Wine, fora do alcance de qualquer hook dentro de `adapter_hook.dll`. |
| `rvpn_reuseport.so` | Shim nativo `LD_PRELOAD`, pré-carregado no `wineserver` (não no serviço — os sockets Unix pertencem ao wineserver). Define `SO_REUSEPORT` em todo socket TCP na criação. O Radmin 2.1 faz travessia NAT por reutilização de porta TCP: ele vincula um listener a `uplink:PORT`, anuncia esse mapeamento, depois vincula seus sockets de peer de saída à mesma porta local com `SO_REUSEADDR`, o que o Windows permite. O Wine traduz essa solicitação em nenhuma opção de nível Unix para TCP (`server/sock.c`, `SO_REUSEPORT` é compilado apenas com `__APPLE__`), então o kernel recusa o segundo bind e o cliente vê `WSAEACCES` em toda conexão de peer (issue #24). A contabilidade de conflitos do próprio wineserver ainda roda, então binds que o Windows recusaria ainda são recusados. |
| `rvpn_filter_ui` | UI GTK4 opcional para inspecionar e filtrar os pacotes que cruzam a ponte. Desativada por padrão; inicie com `--filter-ui`. |
## Solução de problemas
**GUI presa em "Aguardando adaptador"**: o driver não está carregando. Verifique se `/tmp/radmin_driver.log` existe e tem conteúdo. Se estiver vazio, o registro do serviço de driver pode estar ausente — exclua o wineprefix e execute novamente.
**Registrado mas nunca "pronto"**: o serviço alcança `Registered as #…` e para ali. Duas causas conhecidas, ambas relatadas pelo bloco de diagnóstico impresso no timeout. (a) Um proxy transparente ou túnel com sua própria política de roteamento (sing-box, clash/mihomo, v2ray…) interceptando a conexão de saída — tais pilhas respondem ao handshake TCP localmente, então o socket lê ESTABLISHED enquanto nada é retransmitido. Exclua `26.0.0.0/8` de suas rotas, e `*.radminte.com` também se você puder alcançá-los diretamente. (b) Um resolvedor que bloqueia consultas reversas de endereços privados (um `docker0` em `172.17.0.1` é o gatilho usual). `rvpn_dnsfix.so` lida com isso, mas é um shim de 64 bits: um Wine de sistema compilado como *old-wow64* o ignora. Solução alternativa ali — adicione uma linha para o endereço em `/etc/hosts`, ou use `contrib/run-in-netns.sh` (que leva o serviço a "pronto" mas mantém a VPN dentro de um namespace: aplicativos do host não conseguem alcançar `26.0.0.0/8`, leia o aviso no cabeçalho dele).
**Seus *outros* aplicativos Wine quebraram depois de rodar o Radmin (`unimplemented function ndis.sys.NdisInitializeReadWriteLock`)**: versões até 1.0.0 deixavam o `winemenubuilder.exe` do Wine rodar, que reescreve as associações de arquivos do host Windows (`.exe`, `.msi`, `.lnk`, `.reg`, `.chm`, …) para abrir em *nosso* prefixo. Outros programas Windows então iniciam dentro do prefixo do Radmin, e se o miniport NDIS real do Radmin (`RvNetMP60`) ainda estiver registrado ali, cada um deles aborta nesse stub ndis. A 1.0.1 desativa o `winemenubuilder` em todos os lugares, remove as entradas que ele escreveu para um prefixo do Radmin e remove `RvNetMP60` de `system.reg` offline — basta rodar a 1.0.1 uma vez e ambos são reparados. Note que `echo $WINEPREFIX` não mostra nada nessa situação: o sequestro vive em `~/.local/share/applications/*.desktop`, não no seu ambiente. Limpeza manual, se preferir:
```bash
grep -rl 'WINEPREFIX=[^"]*radmin' ~/.local/share/applications --include='*.desktop' | xargs -r rm
rm -rf ~/.local/share/applications/wine/Programs/"Radmin VPN"
update-desktop-database ~/.local/share/applications
```
**Online e nas suas redes, mas nenhum peer conecta (`error: 0x700000000`)**: isto é o Radmin 2.1 em uma build mais antiga que 1.1.0. O log do serviço parece saudável até as conexões de peer, que então falham em loop com esse código e finalmente desistem com `node offline`. Duas lacunas independentes do Wine, ambas corrigidas na 1.1.0 e ambas explicadas acima nas linhas `rvpn_reuseport.so` e `adapter_hook.dll`: o Wine não define nenhuma opção de nível Unix para um TCP `SO_REUSEADDR`, então a travessia NAT por reutilização de porta do 2.1 recebe `WSAEACCES` em toda conexão de peer; e o `advapi32` do Wine não tem quatro exports de perflib, sem os quais o 2.1 envia um payload nulo como seu handshake de peer. Note que o código em si não carrega informação — é a desistência genérica no fim da cascata de erros, então não tente ler um subsistema dele. A correção é atualizar este projeto para 1.1.0; nada precisa mudar no lado do Radmin.
**Serviço morre imediatamente**: verifique `/tmp/radmin_service.log` para erros do Wine. Causa comum: wineprefix antigo de uma versão diferente do Wine. Exclua `./wineprefix/` e execute novamente.
**0% de perda de pacotes com um peer, alta perda com muitos**: este era o bug original — corrigido pelo roteamento de quadros baseado em MAC no driver. Certifique-se de estar usando a build mais recente.
**Primeiro ping é lento (~1s)**: a versão mais recente armazena em cache endereços MAC para cada pacote IP que o driver vê. Se o IP de destino enviou pelo menos um pacote enquanto o driver estava rodando, o MAC já está em cache e não há atraso de ARP. Apenas peers completamente silenciosos (aqueles que nunca enviaram um pacote) exigem a resolução ARP inicial, que adiciona ~1 segundo.
**Jogos de LAN não veem outros peers / "auto-descoberta" quebrada**: a maioria dos jogos de LAN se descobre com sondas de broadcast (UDP para `255.255.255.255`) ou multicast (`224.0.0.0/4`). No Windows, o driver TAP do Radmin se anuncia como a interface preferida para esses fluxos; no Linux você precisa dizer ao kernel explicitamente. O `run.sh` agora instala duas rotas extras quando a VPN sobe:
```
ip route append 255.255.255.255/32 dev radminvpn0 metric 0
ip route append 224.0.0.0/4 dev radminvpn0 metric 0
```
Efeito colateral: mDNS / Bonjour / SSDP na sua LAN física (Chromecast, AirPrint, Sonos, smart TVs, ...) passarão pela VPN enquanto ela estiver ativa. Se você precisar de descoberta de LAN local e Radmin em paralelo, execute com `--no-broadcast-routes`:
```bash
./run.sh --no-broadcast-routes
```
As rotas são limitadas ao dispositivo TAP, então são removidas automaticamente quando o `run.sh` derruba o dispositivo na saída.
## Limitações conhecidas
- Apenas uma instância pode rodar por vez (FIFOs compartilhados em `/tmp/`)
- A rota on-link `26.0.0.0/8` afeta todo o sistema enquanto roda (limpa na saída)
- As rotas padrão de broadcast (`255.255.255.255/32`) e multicast (`224.0.0.0/4`) são direcionadas à VPN — desative com `--no-broadcast-routes` se precisar de mDNS / SSDP de LAN local em paralelo
- Versões mais antigas do Wine (< 11.0) podem ter comportamento diferente de I/O sobreposto que quebra o driver
## Notas
**Solução para bug do Wine.** O hook `RegSetKeySecurity` contorna uma [limitação conhecida do Wine](https://forum.winehq.org/viewtopic.php?t=37183) onde serviços não recebem o SID SYSTEM (S-1-5-18). Isso pode ser corrigido upstream em uma versão futura do Wine.
## Créditos
Engenharia reversa e o shim do Wine: [@baptisterajaut](https://github.com/baptisterajaut).
- [@ayozetr](https://github.com/ayozetr) — rastreou o travamento "registra mas nunca pronto" até uma
consulta de DNS reverso de um endereço privado bloqueado pelo resolvedor do host, provou com um
repro de libc pura depois que quatro teorias erradas foram descartadas (a minha incluída), e escreveu
o original de `src/rvpn_dnsfix.c` e `contrib/run-in-netns.sh`.
- [@gringoestrangeiro](https://github.com/gringoestrangeiro) — trabalho de estabilidade Linux: filtros de pacotes,
cache ARP, recuperação de crash, modos sem cabeça e datacenter.
- [@yuxiaole-bili](https://github.com/yuxiaole-bili) — descobriu que o SCM do Wine inicia automaticamente uma segunda
instância de serviço sem hook que disputa com a injetada pelo adaptador.
- [@D1spell-tech](https://github.com/D1spell-tech), [@Milkiway13](https://github.com/Milkiway13) e
todos que colaram um bloco de diagnóstico completo — dois hosts independentes é o que torna um bug encontrável.
## Licença
GPL-3.0. Veja [LICENSE](https://github.com/baptisterajaut/radmin-vpn-linux/blob/main/LICENSE).
Em espírito, este código é domínio público — faça o que quiser com ele. A GPL está aqui como uma rede de segurança legal: ela protege explicitamente a engenharia reversa para interoperabilidade, que é o que este projeto faz. Cinto e suspensórios.
O Radmin VPN é software proprietário da Famatech Corp. Este projeto fornece apenas ferramentas de interoperabilidade — nenhum código da Famatech é incluído ou distribuído.