Ganhando acesso à rede

Até aqui, criamos uma conexão ponto a ponto entre o servidor e o cliente. Esta é uma solução mais do que satisfatória para casos em que você quer apenas acessar o servidor da empresa enquanto estiver em casa (ou vice-versa), mas ainda não é uma VPN completa, já que você não tem acesso aos outros micros da rede. Para ganhar acesso, existem duas opções:

a) Configurar o servidor para rotear os pacotes (mais simples).
b) Criar um bridge no servidor, unificando as duas interfaces.

Apara ativar a opção A, rode os comandos abaixo no servidor depois de criar o túnel (você pode executá-los abrindo outra conexão via SSH):

# echo 1 > /proc/sys/net/ipv4/ip_forward
# iptables -t nat -s 10.0.0.2 -A POSTROUTING -o eth1 -j MASQUERADE

No comando, o “10.0.0.2” é o endereço da interface tap0 do cliente e o “eth1” é a interface de rede local do servidor. Ele orienta o servidor a rotear todos os pacotes recebidos a partir do cliente para a interface de rede local, devolvendo as respostas.

Em seguida, é necessário executar o comando abaixo, no cliente, orientando-o a usar o servidor como gateway ao tentar acessar endereços dentro da rede:

# route add -net 192.168.1.0 netmask 255.255.255.0 gw 10.0.0.1 dev tap0

No comando, o “192.168.1.0” indica a faixa de endereços usada na rede local do servidor, o “255.255.255.0” indica a máscara e o “10.0.0.1” indica o endereço da interface tap0 do servidor.

Com isso, o cliente passa a encaminhar todas as tentativas de acesso a endereços dentro da faixa especificada para o servidor (usando a interface tap0) e o servidor as encaminha para a interface de rede local, fechando o ciclo.

Usando esta opção, seu PC ganha acesso aos demais micros dentro da rede local do servidor via NAT, mas não é visto por eles. Para criar uma conexão bidirecional, permitindo que o cliente receba um endereço válido dentro da rede local do servidor e seja visto pelos demais PCs, é necessário usar a opção B, criando um bridge entre a interface de rede local do servidor e a interface tap0 da VPN.

Para isso, precisaremos do pacote “bridge-utils” (no servidor), que deve ser instalado através do gerenciador de pacotes. Ele faz parte de todas as principais distribuições, por isso a instalação não será um problema.

Ele contém o comando “brctl”, que permite unir duas ou mais interfaces, criando uma única interface (com um único endereço IP), que age como um bridge onde as duas interfaces “reais” estão conectadas, repassando os frames de um lado para o outro, algo similar às “conexões de ponte” introduzidas no Windows XP.

Com o pacote instalado, crie o script “/etc/init.d/bridge” (você pode usar outro nome qualquer, este é só um exemplo), no servidor, contendo os comandos abaixo, usados para criar o bridge e incluir nele a interface eth1:

#!/bin/sh
ifconfig eth1 0.0.0.0 up
brctl addbr br0
brctl addif br0 eth0
ifconfig br0 192.168.1.254 netmask 255.255.255.0 broadcast 192.168.1.255 up

O script começa zerando o endereço IP da placa “eth1”, que no exemplo é a placa de rede local do servidor, cria a interface “br0” (que é a interface bridge, onde adicionaremos a interface tap0 a seguir), adiciona a eth0 ao bridge e em seguida configura a interface tap0, atribuindo a ela o endereço IP, máscara e endereço de broadcast que antes eram usados pela interface eth1 (lembre-se de substituir os endereços pelos usados no seu caso).

Caso o servidor use a interface para acessar a web (como no caso de um servidor de rede local, que possui uma única interface de rede e acessa através de uma conexão compartilhada via NAT), é necessário incluir também o comando abaixo, que especifica o gateway da rede local, usado pelo servidor para acessar a web:

route add default gw 192.168.1.1 dev br0

Depois de criar o script e marcar a permissão de execução, falta apenas executá-lo (no servidor):

# /etc/init.d/bridge

Depois de executar o script, rode o comando “ifconfig” no servidor e você verá que ele agora possui duas interfaces, a “eth1”, que fica sem endereço IP atribuído, e a interface “br0”, que assumiu o lugar dela. O servidor continua acessível através do mesmo endereço IP, de forma que os demais PCs continuarão tendo acesso normal a ele, mas a criação da interface br0 permite que agreguemos a interface tap0 posteriormente, unificando as duas interfaces.

O próximo passo é criar o túnel no cliente, usando o comando abaixo. Veja que agora definimos o endereço “0.0.0.0” para a interface tap0, deixando-a pronta para ser inserida no bridge:

# ssh -f -w 0:0 -o Tunnel=ethernet root@servidor ifconfig tap0 0.0.0.0

Em seguida, rode no servidor o comando que adiciona a interface tap0 ao bridge:

# brctl addif br0 tap0

Concluindo, levante a interface tap0 no cliente, atribuindo a ela um endereço IP vago dentro da faixa usada na rede local do servidor, como em:

# ifconfig tap0 192.168.1.68 netmask 255.255.255.0 up

Com isso, o cliente passa a oficialmente fazer parte da rede local do servidor, recebendo um IP válido e tendo acesso a compartilhamentos de rede, impressoras e outros recursos, não apenas do servidor, mas também das demais máquinas da rede. Veja só:

index_html_22422a20

A única diferença prática é que a velocidade da conexão é mais baixa, já que o acesso é feito através do link de internet.

Concluindo, depois de testar a VPN o próximo passo é automatizar o processo, para que você não precise executar os mesmos comandos a cada conexão.

O primeiro passo é conseguir um endereço permanente para o servidor, já que não adianta nada automatizar a criação da VPN se a cada conexão você precisar ligar para perguntar qual é o IP atual. Ao usar uma conexão com IP dinâmico, use algum servidor de DNS dinâmico, como o http://www.no-ip.com ou o http://www.dyndns.org.

Voltando à configuração, o primeiro passo é fazer com que o servidor passe a executar o script que cria a interface bridge durante o boot, de forma que você não precise mais executá-lo manualmente conectando-se via SSH a partir do cliente cada vez que quiser fazer a conexão. Para isso, crie o link “/etc/rc5.d/S99bridge” (no servidor) apontando para o script criado, como em:

# cd /etc/rc5.d
# ln -sf ../init.d/bridge S99bridge

Crie agora um script no cliente, contendo os comandos abaixo:

#!/bin/sh
ssh -f -w 0:0 -o Tunnel=ethernet root@servidor “ifconfig
tap0 0.0.0.0; brctl addif br0 tap0″
sleep 10
ifconfig tap0 192.168.1.68 netmask 255.255.255.0 up

Veja que o comando do SSH é um pouco diferente, já incluindo o “brctl addif br0 tap0”. Isso facilita o seu trabalho, já que você não precisará mais se conectar ao servidor via SSH depois de criar o túnel só para executar o comando. Aproveitei também para incluir no script o comando que levanta a interface tap0 no cliente.

Com o servidor configurado para ativar o bridge durante o boot e o script criado no cliente, tudo fica mais simples, pois você precisará apenas executar o script para criar a conexão, esteja onde estiver.

Sobre o Autor

Redes Sociais:

Deixe seu comentário

X