Mostrando postagens com marcador IPTABLES. Mostrar todas as postagens
Mostrando postagens com marcador IPTABLES. Mostrar todas as postagens

sexta-feira, 16 de maio de 2008

Estrutura do Iptables

Introdução: o que esperar deste artigo

Ao contrário de outros artigos e tutoriais sobre iptables, este não se dispõe a ensinar sua sintaxe, como construir regras e como bloquear este ou aquele tipo de pacote. Artigos meus futuros poderão passear por este caminho, muito embora já se tenha muito material na Internet sobre isto.

Ele se destina a explicar a origem dos termos "tabelas" do iptables, o que é e para que servem as tabelas nat, filter e mangle. Onde, ou seja, em qual tabela se deve colocar as regras para este ou aquele objetivo.

Este artigo aproveita também para esclarecer algumas diferenças interessantes, como para que serve o REJECT e qual a diferença dele para o DROP?

Algumas definições serão relevantes e merecem serem citadas antes da leitura:

Quando falo de "nível" no artigo (ex: nível de Enlace) estou me referindo ao modelo de camadas TCP/IP, composto por apenas QUATRO camadas e não SETE como no modelo OSI. No modelo TCP as camadas são o ENLACE, onde se tem na sua imensa maioria o padrão de rede Ethernet como referência:
  • O nível de REDE, responsável pelo roteamento, onde se tem o IP na sua versão 4 como mais significativo;
  • O nível de TRANSPORTE, com seus pacotes UDP e TCP, dentre outros;
  • O o nível de aplicação, com os protocolos FTP, HTTP, etc;
  • O nível FÍSICO não faz parte do modelo de camadas TCP/IP, pois é restrito ao fabricante da placa.

Em termos de nomenclatura geralmente se generaliza chamando tudo de pacote. Porém, quando se quer deixar mais específico em qual nível estamos lidando, pode-se se usar a nomenclatura "quadro" para o nível de Enlace, "datagrama" ip para o nível de rede e "pacote" para o de transporte (sendo que o TCP muitas vezes usam a palavra "segmento"). Na aplicação o que tem são dados.

Mas como o iptables atua em princípio nas camadas de rede, ip de origem ou de destino, e na de transporte (porta origem e destino), o pacote pode ser considerado, neste artigo, como um termo genérico (OBS: é certo que o iptables também permite atuar no enlace e até mesmo na aplicação, com os devidos módulos adicionados).

Por onde passa um datagrama

O iptables, presente no Linux a partir do kernel 2.4, usa o conceito de "ganchos" do netfilter, permitindo avaliar um datagrama em alguns pontos dentro do kernel.



Conforme pode ser observado na Figura 1, um datagrama IP dentro do kernel do Linux passa por várias etapas. Basicamente um datagrama IP é de um dentre três tipos:
  1. O datagrama chegou por uma de suas interfaces, o nível de enlace viu o seu mac address no quadro ethernet. Contudo o datagrama não é destinado ao número IP desta máquina. Se a máquina não for configurada para atuar como roteador, o datagrama é descartado. Se a máquina estiver atuando como roteador, o datagrama deve ser roteado por ela.
  2. O datagrama chegou por uma de suas interfaces, o nível de enlace viu o seu mac address no quadro ethernet e ele é destinado ao IP desta máquina, logo deve ser entregue a um de seus processos locais (se for HTTP, por exemplo, deve ser entregue ao apache).
  3. O datagrama IP foi gerado por um de seus processos locais, por um cliente de email por exemplo, e deve ser repassado a outra máquina.
    Cada datagrama passa por uma etapa de roteamento, onde o kernel decide para onde ele vai. Nesta etapa é que são consultadas, se for o caso, as tabelas de roteamento. Os do tipo 1 devem serem roteados para fora da máquina, que no caso deve estar atuando como roteador, sendo que na etapa de roteamento o kernel decide qual o próximo ponto de rota que deve ser usada. Se for para o IP desta máquina, é o roteamento que verifica isto (isto é, recebe o datagrama, vê que é local e entrega ao nível de transporte, que irá repassá-lo ao processo correspondente).

    Da mesma forma, pacotes os gerados por processos locais também passam pelo roteamento para serem encaminhados. Logo, todos os datagramas passam, de uma forma ou de outra, pela etapa de roteamento.

    Caso ele precise ser repassado a outra máquina (somente se ela estiver atuando como roteador IP), a etapa de "repasse de pacotes" realiza as alterações necessárias, como a reescrita total do cabeçalho de enlace (trocando o MAC origem para o seu), atualização do TTL, etc. Evidente que isto após a decisão de roteamento, pois a escrita do cabeçalho de enlace leva em conta o destino.

Ganchos do netfilter

O netfilter introduziu "ganchos", pontos ao longo do ciclo de vida de um datagrama onde o mesmo pode ser avaliado por regras de firewall. A Figura 2 destaca estes pontos.



Pode-se observar pela Figura 2, que:
  • Um datagrama destinado ao processo local:
    • Pode ser capturado para avaliação ao entrar na Interface, pelo gancho 1, chamado pelo kernel de PREROUTING.
    • Pode ser capturado para avaliação pelo gancho 4, chamado pelo kernel de INPUT.

  • Um datagrama gerado por um processo local:
    • Pode ser capturado para avaliação pelo gancho 5, chamado pelo kernel de OUTPUT.
    • Pode ser capturado para avaliação pelo gancho 3, chamado de POSTROUTING.

  • Um datagrama que esteja apenas passando por esta máquina, não gerada e não destinada ao ip ela:
    • Pode ser capturado para avaliação ao entrar na Interface, pelo gancho 1, chamado pelo kernel de PREROUTING.
    • Pode ser capturado para avaliação pelo gancho 2, chamado pelo kernel de FORWARD.
    • Pode ser capturado para avaliação pelo gancho 3, chamado de POSTROUTING.


Por existirem estes ganchos e a possibilidade de avaliar um datagrama e tomar decisões de firewall sobre ele nestes pontos, o iptables introduz filas de regras (listas) nestes pontos. Cada gancho pode possuir um ou mais conjuntos de regras.


Enfim, as tabelas

Ao todo são três as tabelas mais importantes do iptables:
  • filter
  • nat
  • mangle

A tabela filter deve conter apenas regras que determinam se um pacote deve ser aceito ou não. Nesta tabela não é possível colocar regras para alterar algum parâmetro, como ip ou porta.

A tabela nat serve para realizar operações de tradução sobre IP e/ou porta, tanto de origem como de destino, muito embora também permita recusá-lo (não será abordada neste artigo).

Por fim a tabela mangle serve para realizar alterações mais profundas e bizarras nos pacotes, como alterar o TTL, TOS, etc (não será abordada neste artigo).

As ações operadas sobre um pacote basicamente podem ser recusá-lo ou deixá-lo passar, mas o iptables possui várias maneiras de "recusar" e ainda permite realizar logs. Como dito, operações de alteração de pacotes, seja IP ou porta, não pode ser realizada na tabela filter, mas sim na nat ou mangle.

Em termos de filtragem, para impedir que pacotes que não queremos entrem na máquina, é a tabela filter que nos interessa.

A tabela filter

Entram nesta tabela o conjunto de regras com finalidades gerais, como bloquear, negar, realizar logs. As regras existentes nesta tabela não tem poder de alterar as configurações dos pacotes. Basicamente todas as regras de filtragem estão nesta tabela, pois ela é de uso geral.

Para inserir uma regra em uma lista, pode-se usar -A para APPEND, inserindo-a no final, ou -I para INSERT, inserindo-a NO INÍCIO (a sintaxe profunda das regras não é o foco deste artigo).

A tabela filter possui três conjuntos de regras, ou seja, três listas sendo que cada uma delas está associada a um gancho:
  • INPUT: esta fila de regras recebe este nome justamente por ser aplicada aos pacotes na posição do gancho 4. Logo apenas os pacotes destinados ao ip da máquina atual serão avaliados por eventuais regras existentes nesta tabela. Sintaticamente para inserir regras nesta lista usa-se os parâmetros de iptables (o comando está incompleto):

    iptables -t filter -A INPUT [regra]

  • OUTPUT: esta fila de regras recebe este nome justamente por atuar no gancho 5 (também chamado pelo kernel de OUTPUT). Logo serão avaliados pelas regras presentes nesta lista apenas os pacotes originados por processos locais da máquina. Sintaticamente para inserir uma regra nesta lista usa-se o comando:

    iptables -t filter -A OUTPUT [regra]

  • FORWARD: esta fila de regras recebe este nome justamente por atuar no gancho 2 (também chamado pelo kernel de FORWARD). Logo serão avaliados por estas regras os pacotes que estão sendo repassados por esta máquina, não são para ela e nem originados por ela. Sintaticamente para inserir uma regra nesta lista usa-se o comando:

    iptables -t filter -A FORWARD [regra]

A tabela filter é a tabela básica do iptables e são em suas listas que devem ser inseridas regras de filtragens gerais, que não são complexas, como proibir ou permitir ips, portas, etc. Na Figura 3 pode ser observado a atuação do conjunto de regras desta tabela sobre os ganchos.



Cada regra pode realizar uma determinada ação ao pacote (representado graficamente por -j), sendo que na filter as seguintes ações são possíveis:
  • REJECT: o pacote, uma vez que casou com a regra, é rejeitado. Demais regras existentes são ignoradas e o pacote definitivamente já teve seu destino selado: será descartado. Se for usado REJECT o remetente do pacote será avisado com uma mensagem de erro, normalmente um ICMP de "porta inatingível" (mas o iptables permite ao usuário mudar o tipo de retorno se ele quiser). Em termos de segurança pode não ser interessante devolver uma resposta ao remetente, pois isto iria inevitavelmente dar a conhecer a ele o número IP do firewall.
  • DROP: o DROP tem o mesmo efeito do REJECT e a mesma aplicação, com a diferença de que não é retornado nenhuma mensagem de erro ao remetente (ele não saberá o que aconteceu com o pacote). Em se tratando de FORWARD (repasse) pode ser conveniente usar DROP ao invés de REJECT para que um possível atacante não saiba o IP do firewall que rejeitou o seu pacote. Mas isto deve ser bem analisado, pois se o remetente não souber o que ocorreu, ele poderá ficar ainda tentando várias vezes até desistir por time out. Se o teu firewall é o roteador principal, não tem porque escondê-lo, pois ele é um ponto de rota mesmo. Mas se ele for transparente (atuando em modo bridge), aí pode ser uma boa estratégia não dar nada ao remetente.
  • ACCEPT: Aceita um pacote, deixando que ele siga o seu percurso. O ACCEPT, como os anteriores, causa o término de teste nesta tabela, ou seja, o pacote já foi aceito e não será mais testado por nenhuma outra regra posterior nesta tabela (mas ainda poderá ser testado por outra tabela, como pela mangle ou nat, por exemplo. Acredito que o único exemplo onde isto possa acontecer é ele ser ACEITO no filter FORWARD, mas ser DROPADO no nat POSTROUTING, já que o nat tem também o poder de realizar DROP).
  • LOG: realiza um log deste pacote no sistema (geralmente no /var/log/syslog ou messages). Ao contrário das demais ações (DROP, ACCEPT e REJECT), ao aplicar um log no pacote o mesmo ainda continua sendo testado pelas regras seguintes da fila atual. Uma ação do tipo LOG não causa o término do teste. Caso seja do interesse do usuário ele pode configurar uma mensagem de log que aparecerá nos logs facilitando a análise.

Conclusão

Este artigo teve como motivação apenas mostrar a estrutura interna do iptables e não ensinar a escrever regras sintaticamente corretas e poderosas.

Através do entendimento correto de como o iptables atua, pode-se determinar onde e de que forma pacotes devem ser filtrados:
  • Se estou configurando um firewall pessoal, na minha máquina desktop ou no meu servidor, sendo que ela não é roteador: as regras para filtrar o conteúdo deverão ir na tabela filter, na lista INPUT para filtrar o que está entrando na minha máquina, destinada ao IP dela e na tabela filter, lista OUTPUT para os pacotes gerados pela minha máquina.
  • Se estou configurando um firewall de rede, que filtra todo o conteúdo que entra e sai da minha rede para o mundo: as regras irão todas na tabela filter, lista FORWARD. Para representar o destino (está entrando ou está saindo) posso usar o parâmetro -i interface ou -o interface (o FORWARD é o único que permite -i e -o na mesma regra, querendo dizer, se estiver entrando por aqui e saindo por ali...).
  • Se meu firewall é um firewall de rede, mas também possui alguns serviços nele, como proxy ou de email, devo inserir regras tando no filter INPUT/OUTPUT para definir a política dele enquanto servidor, como no filter FORWARD para proteger minha rede. Regras adicionadas no filter FORWARD não atuam sobre pacotes destinados ao número IP de uma máquina.
  • Se desejo alterar características de ip ou porta, trocando-as, devo usar a tabela nat e para isto preciso aguardar o próximo artigo. :-D

Créditos:
Elgio Schlemer
http://www.vivaolinux.com.br/artigos/verArtigo.php?codigo=6834&pagina=1

Tabela Filter - IPTABLES

FIREWALL COM IPTABLES

Tabela Filter

Vejamos o funcionamento da tabela filter (default) e as suas respectivas chains:

São três, as possíveis chains:

--> INPUT: utilizada quando o destino final é a própria máquina filtro;

--> OUTPUT: qualquer pacote gerado na máquina fltro e que deva sair para a rede será tratado pela chain OUTPUT;

--> FORWARD: qualquer pacote que atravessa o fltro, oriundo de uma máquina e direcionado a outra, será tratado pela chain FORWARD.

Regras de filtragem

As regras (rules) de fitragem, geralmente, são compostas assim:

#iptables [-t tabela] [opção] [chain] [dados] -j [ação]

Exemplo:

#iptables -A FORWARD -d 192.168.1.1 -j DROP

A linha acima determina que todos os pacotes destinados à máquina 192.168.1.1 devem ser descartados. No caso:

tabela: filter (é a default)

opção: -A

chain: FORWARD

dados: -d 192.168.1.1

ação: DROP

Existem outras possibilidades que fogem à sintaxe mostrada anteriormente. É o caso do comando #iptables -L, que mostra as regras em vigor.


Ações

As principais ações são:

ACCEPT --> Aceitar. Permite a passagem do pacote.

DROP --> Abandonar. Não permite a passagem do pacote, descartando-o. Não avisa a origem sobre o ocorrido.

REJECT --> Igual ao DROP, mas avisa a origem sobre o ocorrido (envia pacote icmp unreachable).

LOG --> Cria um log referente à regra, em /var/log/messages. Usar antes de outras ações.

Exemplos comentados de regras de filtragem (tabela filter)

---------------------------------------

#iptables -L

Lista todas as regras existentes.

---------------------------------------

#iptables -F

Apaga todas as regras sem alterar a política.

---------------------------------------

#iptables -P FORWARD DROP

Estabelece uma política de proibição inicial de passagem de pacotes entre sub-redes.

---------------------------------------

#iptables -A FORWARD -j DROP

Todos os pacotes oriundos de qualquer sub-rede e destinados a qualquer sub-rede deverão ser descartados.

---------------------------------------

#iptables -A FORWARD -j ACCEPT

Todos os pacotes oriundos de qualquer sub-rede e destinados a qualquer sub-rede deverão ser aceitos.

---------------------------------------

#iptables -A FORWARD -s 10.0.0.0/8 -d www.chat.com.br -j DROP

Os pacotes oriundos da sub-rede 10.0.0.0 (máscara 255.0.0.0) e destinados aos hosts cujos endereços IP respondem pelo nome www.chat.com.br deverão ser descartados. Note que se a máquina possuir domínios virtuais, todos esses serão bloqueados.

---------------------------------------

#iptables -A FORWARD -s 10.0.0.0/8 -d www.chat.com.br -j REJECT

Os pacotes oriundos da sub-rede 10.0.0.0 (máscara 255.0.0.0) e destinados aos hosts cujos endereços IP respondem pelo nome www.chat.com.br deverão ser descartados. Deverá ser enviado um ICMP avisando à origem.

---------------------------------------

#iptables -A FORWARD -d www.chat.com.br -j DROP

Os pacotes oriundos de qualquer lugar e destinados aos hosts cujos endereços IP respondem pelo nome www.chat.com.br deverão ser descartados.

---------------------------------------

#iptables -A FORWARD -d 10.0.0.0/8 -s www.chat.com.br -j DROP

Os pacotes destinados à sub-rede 10.0.0.0 (máscara 255.0.0.0) e oriundos aos hosts cujos endereços IP respondem pelo nome www.chat.com.br deverão ser descartados.

---------------------------------------

#iptables -A FORWARD -s www.chat.com.br -j DROP

Os pacotes oriundos aos hosts cujos endereços IP respondem pelo nome www.chat.com.br e destinados a qualquer lugar deverão ser descartados.

---------------------------------------

#iptables -A FORWARD -s 200.221.20.0/24 -j DROP

Os pacotes oriundos da sub-rede 200.221.20.0 (máscara 255.255.255.0) e destinados a qualquer lugar deverão ser descartados.

---------------------------------------

#iptables -A FORWARD -s 10.0.0.5 -p icmp -j DROP

Os pacotes icmp oriundos do host 10.0.0.5 e destinados a qualquer lugar deverão ser descartados.

---------------------------------------

#iptables -A FORWARD -i eth0 -j ACCEPT

Os pacotes que entrarem pela interface eth0 serão aceitos.

---------------------------------------

#iptables -A FORWARD -i ! eth0 -j ACCEPT

Os pacotes que entrarem por qualquer interface, exceto a eth0, serão aceitos.

---------------------------------------

#iptables -A FORWARD -s 10.0.0.5 -p tcp --sport 80 -j LOG

O tráfego de pacotes TCP oriundos da porta 80 do host 10.0.0.5 e destinados a qualquer lugar deverá ser gravado em log. No caso, /var/log/messages.

---------------------------------------

#iptables -A FORWARD -p tcp --dport 25 -j ACCEPT

Os pacotes TCP destinados à porta 25 de qualquer host deverão ser aceitos.

---------------------------------------

Créditos:
João Eriberto Mota Filho

Veja o artigo completo em http://www.eriberto.pro.br/iptables/

FIREWALL COM IPTABLES

2. GENERALIDADES

Sistemas de Firewall

Muitos não conhecem o verdadeiro significado do vocábulo firewall. Firewall é um sistema integrado, utilizado em redes de computadores para a sua proteção. Tal sistema é composto por filtros de pacotes, filtros de estados, IDS, IPS, proxies etc. Assim sendo, é errado dizer que uma máquina rodando Iptables é o firewall de uma rede. Isso por que o Iptables é um mero filtro de pacotes e estados. Assim sendo, só consegue analisar dados contidos no cabeçalho IP do pacote que trafega. Ele, por exemplo, não consegue verificar o conteúdo de um pacote. Com isso, um ataque ou um vírus poderão adentrar à rede.

A figura a seguir mostrará um exemplo de um sistema de firewall. A área cinza representa tal sistema.


É possível concluir que um único programa, como o Iptables, não constitui um firewall e sim parte dele. Um administrador de rede deve considerar o uso de outros elementos de segurança. RECOMENDO, DENTRE OUTROS, O USO DO IPS HLBR, DISPONÍVEL EM http://hlbr.sourceforge.net, juntamente com o Iptables. Se preferir, clique aqui para fazer download.

Filtragem de Pacotes

O Iptables é um filtro de pacotes. Essa filtragem poderá ocorrer em duas sitações:

--> diretamente em uma máquina de destino;

--> em uma máquina intermediária responsável pelo roteamento de dados entre segmentos de rede.

Vamos considerar a filtragem de pacotes no caso de controle do roteamento. Então, vamos configurar uma máquina capaz de tomar decisões em relação ao tráfego de rede. Assim, analisaremos o filtro de pacotes existente no Linux. Ele verifica apenas o cabeçalho de cada pacote. Basicamente, só entende endereço IP, máscara de sub-rede, portas e tipos de protocolos IP. Não analisa o conteúdo do pacote e nem identifica ataques.

A filtragem de pacotes é uma atividade interna do kernel.

Os filtros Linux

O filtro de pacotes, na maioria das vezes, atua como um roteador controlado. É uma atividade interna, uma propriedade, do kernel.

São os seguintes, os filtros existentes:

--> kernel 2.0.x: ipfwadm;

--> kernel 2.2.x: ipchains;

--> kernel 2.4.x: iptables;

--> kernel 2.6.x: iptables.

Obs: um kernel é estável quando o algarismo existente entre os dois pontos é par. Exemplo: x.2.x é estável. Já o x.3.x não é estável.

O Kernel 2.4, por questões de compatibilidade, mantém os filtros ipfwadm e ipchains. No entanto, eles não funcionam completamente com esse kernel. Além disso, se o ipchains estiver ativo, o iptables não irá funcionar. Assim, no Red Hat, torna-se necessário entrar no #setup e:

--> habilitar o iptables;

--> desabilitar o ipchains.

Se a distribuição utilizada não possuir o comando #setup, utilize o comando #rmmod ipchains. Cabe ressaltar que o iptables terá os seus módulos básicos carregados quando for utilizado pela primeira vez.

Como funciona um filtro de pacotes?

O FILTRO DE PACOTES do Linux funciona mediante regras estabelecidas. Todos os pacotes entram no kernel para serem analisados. As CHAINS (correntes) são as situações possíveis dentro do kernel. Quando um pacote entra no kernel, este verifica o destino do pacote e decide qual chain irá tratar do pacote. Isso se chama roteamento interno. Os tipos de chains irão depender da tabela que estaremos utilizando no momento. Existem 3 tabelas possíveis:

--> filter: é a tabela default. Quando não especificarmos a tabela, a filter será utilizada. Refere-se às atividades normais de tráfego de dados, sem a ocorrência de NAT. Admite as chains INPUT, OUTPUT e FORWARD.

--> nat: utilizada quando há NAT. Exemplo: passagem de dados de uma rede privada para a Internet. Admite as chains PREROUTING, OUTPUT e POSTROUTING.

--> mangle: basicamente, trabalha com marcação de pacotes e QoS. Neste tutorial, não trataremos dessa tabela.

O Iptables é stateful, ou seja, trabalha com os estados das conexões. O ipfwadm e o ipchais são stateless.

Créditos:

João Eriberto Mota Filho
www.eriberto.pro.br/iptables

IPTABLES

FIREWALL COM IPTABLES

1. IP FORWARD

Considerações iniciais

O IP FORWARD é um tipo de roteamento. É estabelecido quando colocamos uma máquina entre dois ou mais segmentos de rede, permitindo a livre passagem de pacotes entre estes sempre que for necessário. É importante ressaltar que o roteamento só irá funcionar quando for feito entre REDES DIFERENTES. Não se pode colocar um roteador entre dois segmentos de rede iguais. Esse procedimentonão serve apenas para estabelecer a comutação de segmentos. Ele também é útil para diminuir o tráfego na rede como um todo, pois só deixa o pacote mudar de segmento se isso for realmente necessário.

Veja a figura a seguir:

Para fazer o IP FORWARD, o micro roteador deverá possuir uma placa de rede com endereço IP pertencente a cada segmento. Também deveremos informar, em cada máquina de cada seguimento, quem será o micro responsável pelo roteamento. O nome técnico desse micro é gateway.

No caso do esquema anterior, temos as seguintes situações:

* Gateway para 10.0.0.1, 10.0.0.2 e 10.0.0.3: a máquina 10.0.0.10

* Gateway para 172.20.0.1, 172.20.0.2 e 172.20.0.3: a máquina 172.20.0.10

É importante que, nos dois lados, todos os micros saibam quem é o seu gateway pois, do contrário, os hosts não saberão para onde enviar os pacotes destinados à rede oposta. Exemplo:

A máquina 10.0.0.1 sabe que 10.0.0.10 é o seu gateway. A máquina 172.20.0.1 não sabe quem é o seu gateway. Um ping de 10.0.0.1 para 172.20.0.1 sairá de 10.0.0.1, passará por 10.0.0.10, seguirá por 172.20.0.10 e chegará em 172.20.0.1. Como 172.20.0.1 não sabe quem é o seu gateway para a rede 10.0.0.0, não conseguirá responder. O ping vai morrer por timeout. Houve o icmp echo request mas será impossível gerar o icmp echo reply.

Fazendo o IP FORWARD

Para estabelecermos o IP FORWARD entre dois segmentos de rede, basta:

* inserir um micro com duas placas de rede entre os segmentos de rede, configurando-as corretamente;

* definir, em cada máquina, de cada segmento, quem é o seu gateway;

* ativar o IP FORWARD via kernel.

O estabelecimento de IP FORWARD entre mais de dois segmentos de rede segue o mesmo princípio, bastando acrescer quantas placas de rede forem necessárias no gateway. Também é possível utilizar placas de fax-modem em conjunto com placas de rede.

Definindo o gateway

Para definirmos o gateway em cada cliente, devemos:

--> No Linux Red Hat/Fedora

Editar o arquivo /etc/sysconfig/network e inserir a linha:

GATEWAY=ip_do_gateway

Em seguida, devemos reiniciar a rede:

#/etc/rc.d/init.d/network restart

--> No Linux Slackware

Editar o arquivo /etc/rc.d/rc.inet1.conf e configurar a linha:

GATEWAY="ip_do_gateway"

Em seguida, devemos reiniciar a rede:

#/etc/rc.d/rc.inet1 restart

--> No Linux Debian

Editar o arquivo /etc/network/interfaces e inserir a linha:

gateway ip_do_gateway

Em seguida, devemos reiniciar a rede:

#/etc/init.d/networking restart

--> No Windows 9x

Nas Propriedades do protocolo TCP/IP, há uma seção gateway. Basta inserir o IP do gateway nessa seção. Exemplo:

--> No Windows XP

Nas Propriedades do protocolo TCP/IP, há uma entrada gateway. Basta inserir o IP do gateway. Exemplo:

--> Outras versões de Windows

Em outras versões de Windows, o procedimento é similar.

Ativando o roteamento via kernel no Linux

O roteamento via kernel será ativado com o comando:

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

Esse roteamento será perdido se a rede (e, em conseqüência, a máquina) for reinicializada (#/etc/rc.d/init.d/network restart).

Poderíamos inserir a regra no fim do arquivo /etc/rc.d/rc.local, para que a mesma seja ativada a cada reinicialização do sistema. No entanto, um reinício da rede mataria o roteamento novamente.

No Red Hat, uma forma de deixar a regra de roteamento permanentemente ativada, resistindo a qualquer tipo de reinicialização, seria a alteração do arquivo /etc/sysctl.conf:

net.ipv4.ip_forward = 1

Já no Debian, a linha a seguir deve ser inserida no arquivo /etc/sysctl.conf:

net/ipv4/ip_forward=1

Teste do roteamento

O teste do roteamento pode ser feito por intermédio do comando ping. Basta "pingar" uma máquina que esteja após o roteador.

Caso não haja resposta, faça um teste progressivo para tentar deduzir o problema:

--> pingue a placa do roteador que esteja dentro do seu segmento de rede;

--> pingue a placa do roteador que esteja no outro segmento;

--> pingue outra máquina do outro segmento.

O programa IPTRAF poderá ajudar a debugar a conexão. Execute a opção "IP traffic monitor" do citado programa na máquina roteadora e verifique se o ICMP echo request está saindo e se o ICMP echo reply está voltando. Se não voltar, o problema estará no segmento de destino do ping.



Créditos:
João Eriberto Mota Filho
http://www.eriberto.pro.br/iptables/