Ativando o compartilhamento

Depois de tudo preparado, ativar o compartilhamento propriamente dito é bastante simples. No Linux, o compartilhamento é feito usando o Iptables, o firewall integrado ao Kernel. Na verdade, o Iptables é expandido através de módulos, por isso suas funções vão muito além das de um firewall tradicional, incluindo funções avançadas de roteamento. Para ativar o compartilhamento, são necessários apenas três comandos:

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

Substitua o “eth1” pela placa da Internet. Este comando simplesmente compartilha a conexão proveniente da placa da internet com todas as demais placas de rede espetadas no servidor, por isso não é necessário especificar a placa de rede local.

O primeiro comando ativa o “iptable_nat“, o módulo do Iptables responsável por oferecer suporte ao roteamento de pacotes via NAT. O segundo ativa o “ip_forward“, o módulo responsável pelo encaminhamento de pacotes, utilizado pelo módulo iptable_nat.

Finalmente, o terceiro cria uma regra de roteamento, que orienta o servidor a direcionar para a internet todos os pacotes (recebidos dos clientes) que se destinarem a endereços que não façam parte da rede local (ou seja, qualquer coisa fora da faixa 192.168.1.x). A partir daí, o servidor passa a ser o gateway da rede.

A maioria das distribuições instalam o executável do Iptables por padrão, mas sempre existem exceções. No Mandriva, por exemplo, ele é instalado ao marcar a categoria “firewall” durante a instalação. Para instalá-lo posteriormente, use o comando “urpmi iptables“.

Em muitas distribuições com o Kernel 2.6, é necessário usar um quarto comando ao compartilhar uma conexão ADSL. Este comando ajusta os tamanhos dos pacotes recebidos do modem ao MTU usado na rede local. Note que, apesar da diagramação do livro tornar necessário quebrar o comando em duas linhas, trata-se de um único comando:

# iptables -A FORWARD -p tcp –tcp-flags SYN,RST SYN -m \
tcpmss –mss 1400:1536 -j TCPMSS –clamp-mss-to-pmtu

A barra invertida (“\”) faz com que o shell não interprete o caractere seguinte (no caso, a quebra de linha), permitindo quebrar o comando em duas linhas, sem causar um erro. Esse é um truque que permite incluir comandos longos demais para caberem na página, divididos em duas linhas ou mais. Na verdade, o comando forma uma única linha.

Como de praxe, é importante proteger o servidor de ataques provenientes da Internet usando um firewall. Podemos ativar um firewall simples de bloqueio usando mais alguns comandos do Iptables, complementando os três comandos anteriores:

iptables -A INPUT -p icmp –icmp-type echo-request -j DROP
echo 1 > /proc/sys/net/ipv4/conf/default/rp_filter
iptables -A INPUT -m state –state INVALID -j DROP
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -j ACCEPT
iptables -A INPUT -p tcp –dport 22 -j ACCEPT
iptables -A INPUT -p tcp –syn -j DROP

O primeiro comando faz com que o seu servidor deixe de responder a pings, o que evita muitos ataques casuais. Os dois comandos seguintes protegem contra IP spoofing (uma técnica usada em diversos tipos de ataques, onde o atacante envia pacotes usando um endereço IP falseado como remetente, tentando assim obter acesso a PCs da rede interna) e contra pacotes inválidos, que são comumente utilizados em ataques DoS e ataques de buffer overflow.

As duas linhas seguintes autorizam pacotes provenientes da interface de loopback (lo), juntamente com pacotes provenientes da rede local. Como pode ver, a sintaxe das regras do Iptables segue um padrão lógico, onde você especifica uma determinada condição e diz o que o firewall deve fazer com os pacotes que se enquadrarem nela. No caso da regra que autoriza os pacotes da rede local (iptables -A INPUT -i eth0 -j ACCEPT) usamos os parâmetros “-A INPUT” (pacotes de entrada) e “-i eth0” (recebidos na interface eth0), seguidos da regra “-j ACCEPT”, que diz que os pacotes devem ser aceitos sem checagem adicional. Não se esqueça de substituir o “eth0” pela interface de rede local correta, caso diferente.

Continuando, a linha “iptables -A INPUT -p tcp –dport 22 -j ACCEPT” abre a porta 22, usada pelo SSH para conexões externas, permitindo que você possa administrar o servidor remotamente. Você pode abrir mais portas simplesmente adicionando mais linhas, com as portas desejadas. Concluindo, temos a linha “iptables -A INPUT -p tcp –syn -j DROP“, que faz o trabalho pesado, bloqueando tentativas de conexão provenientes da Internet.

Depois de testar o compartilhamento, falta fazer com que os comandos sejam executados durante o boot, tornando a configuração permanente. A forma mais simples de fazer isso é colocar os comandos no arquivo “/etc/rc.local“, um script próprio para a tarefa, que está disponível tanto em distribuições derivadas do Debian quanto em distribuições da linhagem do Red Hat. Um exemplo de arquivo completo, incluindo os comandos para ativar o firewall seria:

#!/bin/sh
# /etc/rc.local

modprobe iptable_nat
echo 1 > /proc/sys/net/ipv4/ip_forward
iptables -t nat -A POSTROUTING -o eth1 -j MASQUERADE

iptables -A INPUT -p icmp –icmp-type echo-request -j DROP
echo 1 > /proc/sys/net/ipv4/conf/default/rp_filter
iptables -A INPUT -m state –state INVALID -j DROP
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i eth0 -j ACCEPT
iptables -A INPUT -p tcp –dport 22 -j ACCEPT
iptables -A INPUT -p tcp –syn -j DROP

Esta receita é genérica, deve funcionar em qualquer distribuição. Lembre-se de substituir “eth1” pela interface de internet e o “eth0” pela interface de rede local, caso diferentes.

Uma segunda opção, mais elegante, porém mais complicada, é criar um serviço de sistema, que pode ser ativado e desativado. Neste caso, crie o arquivo de texto “/etc/init.d/compartilhar“. Dentro dele vão as linhas a seguir:

#!/bin/bash

# Interface da Internet:
ifinternet=”eth1“

# Interface da rede local
iflocal=”eth0“

iniciar(){
modprobe iptable_nat
echo 1 > /proc/sys/net/ipv4/ip_forward
iptables -t nat -A POSTROUTING -o $ifinternet -j MASQUERADE
iptables -A INPUT -p icmp –icmp-type echo-request -j DROP
echo 1 > /proc/sys/net/ipv4/conf/default/rp_filter
iptables -A INPUT -m state –state INVALID -j DROP
iptables -A INPUT -i lo -j ACCEPT
iptables -A INPUT -i $iflocal -j ACCEPT
iptables -A INPUT -p tcp –dport 22 -j ACCEPT
iptables -A INPUT -p tcp –syn -j DROP
}

parar(){
iptables -F
iptables -F -t nat
}

case “$1” in
“start”) iniciar ;;
“stop”) parar ;;
“restart”) parar; iniciar ;;
*) echo “Use os parâmetros start ou stop”
esac

Este é um shell script que aceita três funções: start, stop e restart, executando dentro de cada uma os comandos que compartilham e param o compartilhamento da conexão. Esta estrutura é similar à usada nos demais scripts de inicialização do sistema, como os do Apache, Samba, Squid e outros serviços.

Veja que em vez de especificar as interfaces de internet e de rede local dentro dos comandos, passei a usar duas variáveis no início do script, que facilitam a configuração e tornam o script mais elegante. Quando precisar usar o script em outra máquina, onde as interfaces sejam diferentes, você precisa apenas se lembrar de alterar as duas variáveis. Note também que os comandos a partir do “iptables -A INPUT -p icmp –icmp-type echo-request -j DROP” correspondem às proteções e ao firewall e podem ser removidos caso desejado.

Para usar o script, transforme-o em um arquivo executável, usando o comando:

# chmod +x /etc/init.d/compartilhar

A partir daí, você pode iniciar e parar o compartilhamento usando os comandos:

# /etc/init.d/compartilhar start
# /etc/init.d/compartilhar stop

Para que o script seja executado durante o boot, você pode adicionar o comando “/etc/init.d/compartilhar start” no arquivo “/etc/rc.local”, em vez de colocar os comandos diretamente, como fizemos no exemplo anterior.

Outra opção (mais elegante) é criar um link para ele dentro da pasta “/etc/rc5.d”, o que também faz com que ele seja executado durante o boot:

# cd /etc/rc5.d
# ln -s ../init.d/compartilhar S21compartilhar

Como vimos no primeiro capítulo, o “S” indica que o script deve ser executado com o parâmetro “start” e o “21” indica a ordem em que deve ser executado durante o boot, em relação aos outros serviços. A ordem de execução dos serviços muda de distribuição para distribuição, mas nessa posição garantimos que ele será executado depois da ativação das interfaces de rede e de outros serviços essenciais.

Se você é um administrador paranóico, verifique a configuração dos serviços na distribuição em uso e altere a ordem de inicialização do script de firewall, de forma que ele seja carregado antes de qualquer outro serviço que aceite conexões, como o Samba ou o Apache. Com isso você garante que o firewall será carregado primeiro e não fica com seu servidor vulnerável nem mesmo por um curto espaço de tempo durante o boot.

Isso nos leva a uma terceira opção para salvar a configuração, utilizando os próprios arquivos de inicialização do sistema. Ela é a mais “correta” do ponto de vista técnico, embora menos flexível. Nesse caso, a configuração seria feita em três passos:

A primeira parada seria o arquivo “/etc/modules”, onde são listados os módulos carregados pelo sistema durante o boot. Nele seria adicionada a linha “iptables_nat”, ativando o carregamento do módulo. Em seguida, você adicionaria (ou descomentaria) a linha “net.ipv4.conf.default.forwarding=1” no arquivo “/etc/sysctl.conf”, para ativar o roteamento de pacotes, tornando permanente o comando “echo 1 > /proc/sys/net/ipv4/ip_forward”.

Finalmente, depois de executar o comando “iptables -t nat -A POSTROUTING -o $placa -j MASQUERADE”, que efetivamente ativa o compartilhamento, você usaria o comando “/etc/init.d/iptables save active” (nas derivadas do Debian) ou “service iptables save” (nas derivadas do Red Hat) para salvar regra e fazer com que ela passe a ser reativada durante o boot.