Revista Do Linux
EDIÇÃO DO MÊS
 Programação
 Estudo de Caso
 Corporativo

 Entrevista
 Capa
 CD do mês
 Debian
 Echelon
 Gimp
 IPChains
 Monopolio
 Wine

 

IPChains: Conexões sem fronteiras
Qualquer computador pode estar ligado à Internet. Essa afirmação, embora continue verdadeira, pode ser substituída por outra mais adequada: qualquer rede de computadores pode estar ligada à Internet

Com o barateamento dos microcomputadores, periféricos e outros acessórios, ter mais de um micro no escritório e até mesmo em casa, passou a ser comum. E a idéia de ter todos esses micros em rede, e essa rede ligada à Internet tornou-se uma alternativa perfeitamente viável para muitos usuários, inclusive domésticos.

E quem já possui essa rede ligada à Internet — ou está pensando nessa possibilidade — não pode deixar de conhecer a ferramenta Ipchains, presente em todas as distribuições mais recentes do kernel. Na verdade, o Ipchains é uma ferramenta do kernel (que nas versões mais antigas denominava-se ipforward, mas cuja operação era diferente do Ipchains, e por isso não será aqui abordada). Essa ferramenta destina-se a fazer a filtragem de pacotes que percorrem a rede e neste artigo será explicado como fazer para que uma rede acesse a Internet através de um único ponto, tanto através de uma conexão permanente quanto de uma discada.

Quando a rede estiver ligada à Internet, o usuário provavelmente vai querer controlar todo o tráfego nessa rede. Ele pode querer que ninguém acesse um determinado site, que não se tenha acesso a um tipo de serviço e, mais que tudo, que ninguém fique bisbilhotando sua rede. Todas essas medidas podem ser realizadas com o Ipchains.

Para começar a trabalhar com o Ipchains é necessário compilar o kernel do Linux para que ele aceite as funções do Ipchains. O roteiro dessa operação não faz parte deste artigo, mas um roteiro básico pode ser definido assim:

1. base da árvore de diretório do kernel # cd /usr/src/linux

2. configurar as opções do kernel


# make menuconfig

3. criar as dependências


# make dep

4. limpar partes inúteis da compilação


# make clean

5. criar a imagem compactada


# make bzImage

6. copiar a imagem compactada para /vmlinuz (no caso do Slackware). Para Debian e derivado, copie o novo kernel no diretório /boot e crie um symlink no diretório raiz. Para RedHat e Conectiva, copie o novo kernel no diretório /boot e crie o symlink dentro do próprio /boot).


# cp /usr/src/linux/arch/i386/boot/bzImage /vmlinuz

7. compilar o lilo e o preparar para usar uma imagem compactada com bzip


# make bzlilo

8. compilar os módulos


# make modules

9. instalar os módulos


# make modules_install

10. garantir que o lilo está reconhecendo a imagem correta


# lilo

Quando você chegar ao segundo passo estará apto a escolher quais opções de configuração deseja. Para nosso objetivo as opções necessárias estão em Networking options. Quando entrar em network options, você deverá ativar o seguinte: Network firewalls ; IP: firewalling ; IP: masquerading ; IP: ICMP masquerading ; IP: optimize as router not host. O ip masquerading só é necessário se você quiser colocar uma rede acessando a Internet através de um único micro.

Assim que você selecionar as opções, grave as mudanças e continue executando os passos. Dependendo da sua máquina e da quantidade de coisas que você colocar no kernel, pode levar de alguns minutos a algumas horas para compilar o kernel todo... por isso aproveite para ler o resto da revista.

Pronto? Terminou? Ótimo. Reinicialize sua máquina (init 6), (aquele seu uptime de centenas de dias vai terminar). Preste atenção para ter certeza de que as mudanças no kernel surtiram os efeitos desejados. Reiniciada a máquina, ela estará pronta para fazer a filtragem de pacotes.

Até aí tudo bem, mas como fazer para colocar dois ou mais computadores em rede ligados à Internet? A resposta é simples.

Um gateway (computador com acesso à Internet) nada mais faz que repassar para frente (Internet) os pacotes que chegam a ele. E como aqui se está falando de filtragem de pacotes, você usará o Ipchains para fazer isso.

Voltando ao Ipchains, a questão básica para se inserir uma regra é:


ipchains -A chain -s ip/masq port -d ip/masq port -p prot -j action -i interface

Traduzindo essa linha:

A opção ‘-A chain’ indica em qual chain (cadeia) a regra que você está criando será inserida. Existem três regras básicas: Input ; Forward ; Output. Cada uma dessas regras define uma ação com o pacote. Pacotes que chegam (input) à máquina, pacotes que serão repassados (forward) e pacotes que saem (output) da máquina. Você poderá criar outras chain de acordo com a sua necessidade. Abaixo estão descritos alguns recursos do Ipchains, mas nem todos serão abordados neste artigo.

As opções para manejo de cadeia (chain) são:

  1. criar um novo chain (-N).
  2. excluir um chain vazio (-X).
  3. alterar o policiamento de um chain embutido (-P).
  4. listar as regras em um chain (-L).
  5. transportar (Flush) as regras fora do chain (-F).
  6. zerar os contadores de pacote e byte em todas as regras no chain (-Z).

Existem diversos meios de manipular regras dentro do chain:

  1. adicionar uma nova regra no chain (-A).
  2. inserir uma nova regra na mesma posição no chain (-I).
  3. substituir uma regra na mesma
  4. posição no chain (-R).
  5. excluir uma regra na mesma posição no chain (-D).
  6. excluir a primeira regra que confere no chain (-D).

Existem poucas operações para masquerading:

  1. lista de conexões atuais do masquerade (-M -L).
  2. configurar os valores de tempo máximo (timeout) do masquerade (-M -S).

Vamos a um exemplo prático. Se você não quiser que nenhum pacote TCP chegue na porta 30 da máquina X, você deve criar a seguinte regra:


ipchains -A input -s 0/0
-d maquinaX 30 -p TCP -j DENY

Pronto, feito isso todos os pacotes TCP que chegarem à porta 30 da máquina X serão bloqueados.

Antes de dar exemplos mais concretos do que pode ser feito com Ipchains, é importante conhecer as opções de cada argumento da linha de comando para inserir uma regra.

-A chain - indica em qual chain será colocada a regra que você está criando;

-s IP/MASQ PORT - indica o source (origem) do pacote. Se a opção -s for omitida, por padrão será colocado

-s 0/0 *, isto é, de qualquer lugar e de qualquer porta;

-d IP/MASQ PORT - indica o destino do pacote. Idem com a opção s;

-p protocol - indica sobre qual protocolo a regra irá agir. TCP, UDP e ICMP (com seus respectivos variantes echo, reply , etc) são aceitos. A opção ALL indica todos os protocolos;

-j action - indica o que vai ser feito com o pacote. Mais precisamente não seria action que vem após o -j e sim jump-to, mas para simplificar colocou-se action. As opções aqui são: Deny (bloquear), Reject (bloquear, mas avisa a origem do pacote o que houve com ele), Accept (aceitar) , Redirect (redirecionar) e Masq (mascarar);

-i interface - indica sobre qual interface a regra irá atuar. eth0, eth1, ppp0 são exemplos de interface. Se essa opção for omitida a regra valerá para todas as interfaces.

Alguns exemplos que podem ser úteis no dia-a-dia:


ipchains -A input -s IP -d 0/0
-p ICMP -j DENY

Essa regra irá bloquear (Deny), sem dar satisfação, os pacotes ICMP vindos de IP. Útil para evitar Ping Flood, comum no IRC.


ipchains -A input -s IP -d 0/0
-p TCP -j DENY

Você entra em algum site que sai abrindo inúmeras janelas do seu browser com propagandas de outras pages? Basta colocar o IP dos sites que apresentam propaganda e pronto, você estará livre delas.


ipchains -A output -s 0/0 -d IP -p TCP -j REJECT

Você tem uma rede na empresa e não quer que acessem certos sites a partir dela? Coloque o IP dos sites e pronto.


ipchains -A output -s 0/0 -d 0/0 6000:8000 -p TCP -j REJECT

Você não quer que ninguém acesse IRC da sua rede? Bloqueie as portas comuns de acesso a esse serviço com um port range, que funciona da seguinte maneira: porta inical:porta final. Caso a porta inicial seja omitida, será colocada a primeira, caso a porta final seja omitida será colocada a última.

A partir desses exemplos pode-se criar infinitas regras que se adaptem à necessidade de sua rede ou do seu gosto pessoal.

Acesso através de um gateway

Para montar o acesso à Internet através de um gateway (um ip válido para N micros), a máquina Linux da rede, que será o gateway, máquina que detém a conexão real com a Internet, deverá ter sua conexão já em funcionamento, da mesma forma que a rede entre todos os micros que participarão dessa conexão com a Internet também já deverá estar funcionando, sendo que todos os micros deverão ser capazes de trocar pacotes entre si (ou seja, um dar ping no outro).

Este artigo também vai mostrar como colocar máquinas Windows na rede. Mas o Windows não deve ser usado como servidor, a não ser que se use programas como o Winproxy, e ainda assim haverá uma queda de performance muito acentuada.

O IP Masquerading funciona da seguinte maneira: duas máquinas

A e B sendo que A tem IP da rede 192.168.1.1 e B 192.168.1.2 . A máquina A será o gateway e, através de uma conexão discada o IP obtido foi 200.251.139.50 para a Internet. A máquina A está navegando normalmente na Internet, podendo acessar HTTP, ftp, etc. B tem como gateway A. Isso significa que, caso o pacote que B tenha que mandar não seja para ele mesmo, ele mandará para A. A irá analisar o pacote e se ele não for para A, ele irá mascará-lo (fingindo que A é o dono do pacote) e mandá-lo para Internet. Esse pacote voltará para A, mas A sabe que B requisitou, então

A mandará o pacote para B e B terá a sensação de estar ligado diretamente à Internet.

Para configurar o server A basta acrescentar as seguintes regras:

# ipchains -P forward DENY
# ipchains -A forward -s 192.168.1.0/24 -j MASQ

Caso não funcione, tente usar também:


# echo 1 > /proc/sys/net/ipv4/ip_forward

Isso quer dizer que qualquer pacote que chegar da rede 192.168.1.0 deverá ser mascarado. Note que 192.168.1.0 é o ip da rede e /24 é a netmask dessa rede que pode ser representado como 255.255.255.0 (o mais comum).

A maior parte da documentação consultada diz que o ipchains não grava suas configurações. Quando usei o ipchains, não tive que me preocupar com isso. Todas as mudanças ficam automaticamente gravadas, caso isso não aconteça coloque estes comandos nos seus arquivos de inicialização.

Para configurar o Client B utilizando Windows 9X:

  1. Vá em Iniciar/Configurações/Redes
  2. Selecione TCP/IP que está linkado com a sua placa de rede e depois clique em propriedades.
  3. Onde tiver a opção gateway coloque o ip da rede da máquina A, no exemplo 192.168.1.1
  4. Reinicie a máquina.

Para configurar o Client B utilizando Linux:


1.route add -net 192.168.1.0
dev eth0

2.route add default gw 192.168.1.1

(Quem disse que o Linux era mais difícil de configurar?)

Digite: route -n e deve aparecer a seguinte saída:

Feito isso os clientes estarão aptos a navegar na Internet quando o gateway estiver navegando. Alguns serviços da Internet requerem portas específicas para funcionar, tais como o IRC, FTP e outros. O ipchains não garante essa segurança na hora de mascarar os pacotes; para resolver isso alguns módulos adicionais ao kernel foram criados. Por isso se desejar usar algum desses serviços será necessário ler o módulo correspondente. Para isso edite o /etc/rc.d/rc.modules ou acrescente a linha /sbin/modprobe módulo ao arquivo /etc/rc.d/rc.local. Esses paths e arquivos são em relação ao Slackware Linux, procure os arquivos correspondentes na sua distribuição.

  • ip_masq_autofw - Auto Forward
  • ip_masq_cuseeme - CUSeeMe
  • ip_masq_ftp - FTP
  • ip_masq_irc - IRC
  • ip_masq_mfw - Reverse-Masq Forward
  • ip_masq_portfw - Port Foward
  • ip_masq_quake- Quake
  • ip_masq_raudio - Real Audio
  • ip_masq_user - User Space Control
  • ip_masq_vdolive - Video Live

    Em casa, onde uso o Ipchains para mascarar a conexão de três máquinas, eu não usei esses módulos e todos os serviços funcionam perfeitamente. Possuo um client Linux (486) e um client Windows 98 (k6-2 300) e o server é um SlackBOX (Pentium 166 MMX).

    Uma questão de segurança

    Mesmo após um halt no sistema, o Linux continuará fazendo o ip forward. Se isso for um problema, você deverá ter certeza de que as interfaces do seu computador não mais funcionem após o halt; basta editar os scripts que finalizam os recursos da máquina (init 6) colocando o comando adequado para desabilitar as interfaces durante o halt.

    Antes de finalizar este artigo, gostaria de deixar claro que ele tem a pretensão de ser apenas uma apresentação ao Ipchains e ao Ipmasquerade, e não seus How-tos completos. Sendo assim inúmeros detalhes foram omitidos e muitas explicações foram reduzidas para melhor clareza. Mesmo para uma utilização básica do Ipchains recomendo a leitura de pelo menos suas manpages. Os How-tos Ipchains e Masquerading são muito bons e de leitura indispensável para um bom entendimento desses conceitos.

    Para saber mais

    Man pages
    Ipchains e Masquerading howto

    Kernel IP routing table
    DestinationGatewayGenmaskFlags MetricRefUseIface
    192.168.1.00.0.0.0255.255.255.0U000eth0
    127.0.0.00.0.0.0255.0.0.0U000lo
    0.0.0.0192.168.1.10.0.0.0UG100eth0
  •  

    A Revista do Linux é editada pela Conectiva S/A
    Todos os Direitos Reservados.

    Política de Privacidade
    Anuncie na Revista do Linux