Conhecendo o IPTABLES e Configurando um Firewall

Tutoriais Diversos em Português

Conhecendo o IPTABLES e Configurando um Firewall

Mensagempor reginaldo » Qui Dez 18, 2008 2:43 pm

Este Tutorial é a união de 3 tutoriais sobre IPTABLES, a saber:

1 - "Pequeno manual IPTABLES" - Autor: ffcouto, que teve como fonte: Internet, Pesquisa Google

2 - "Mini Tutórial de IPtables" - Autor: Carlos Henrique Quadadro, que teve como Fonte: Site da PUC do Paraná.

3 - "Montando ou Aperfeiçoando um Firewall com Iptables ..." - Autor: aryribeiro= Ary Ribeiro.


**************************************************************************************************************************

Firewall com Iptables

Um firewall, ou filtro de pacotes, é um recurso utilizado para proteger uma máquina ou uma rede através do controle e filtragem dos pacotes de dados que entram ou que saem. No Linux esse recurso é implementado diretamente no kernel e recebe, nas versões de kernel 2.4 ou superior, o nome de netfilter. Além da simples filtragem de pacotes, o netfilter é capaz de manipular campos dos cabeçalhos de pacotes, fazer a tradução de endereços de rede (NAT), "marcar" pacotes e fazer o acompanhamento de conexões (connection track). Este último recurso faz com o que o netfilter seja um firewall do tipo "statefull", ou seja, capaz de reconhecer o "estado" de uma conexão.

Tabelas e Chains

Tabela é o local utilizado para armazenar chains que por sua vez contém regras. O netfilter possui três tabelas: filter, mangle e nat. Cada tabela é utilizada para propósitos diferentes: a tabela filter é utilizada para aceitar ou rejeitar pacotes; a tabela mangle é usada para manipular alguns campos do cabeçalho IP, como por exemplo, o campo TOS e o campo TTL. A tabela mangle também pode ser utilizada para se inserir "marcas" no pacote; a tabela nat é utilizada para fazer Traduções de Endereços de Rede (NAT).

Uma chain é simplesmente um conjunto de regras, no entanto existem dois tipos de chains: as chains do kernel e as chains criadas pelo usuário. As chains do kernel - PREROUTING, INPUT, FORWARD, OUPUT e POSTROUTING - estão ligadas a pontos especiais no caminho que os pacotes precorrem ao entrar e sair da máquina. Enquanto que as chains do usuário não estão ligadas a ponto algum, logo, é necessário que uma chain do kernel tenha como alvo uma chain de usuário para que os pacotes percorram essa chain.

A chain PREROUTING é percorrida pelos pacotes que chegam à interface de rede, mas antes da consulta às tabelas de roteamento. Após esse ponto é feita a decisão de roteamento e o pacote poderá ser destinado à máquina local, e nesse caso percorrerá a chain INPUT, ou será roteado para outra máquina e percorrerá então a chain FORWARD. Os pacotes antes de saírem pela interface de rede percorrem a chain OUTPUT, caso tenham sido originados na máquina local, e a chain POSTROUTING, que é chain consultada após a tomada de decisão de roteamento, quando os pacotes estão prestes a sair da máquina.

É importante ressaltar que a filtragem de pacotes é feita em basicamente 3 lugares: nas chains INPUT e OUTPUT para pacotes com origem e destino na máquina local, e na chain FORWARD para pacotes que atravessam o roteador.

Regras

Uma regra do netfilter descreve o que fazer, onde e com que tipo ou padrão de pacote. Ao criarmos uma regra, especificamos em que tabela e chain estamos inserindo essa regra, definimos um padrão que irá casar com os pacotes, utilizando para isso os campos do cabeçalho do pacote e finalmente especificamos um "alvo" para a regra, que poderá ser uma ação como aceitar ou rejeitar o pacote, ou poderá ser um "jump" para uma outra chain.

Quando um pacote "entra" numa chain, cada regra é avaliada, de maneira sequencial, até que o pacote case com uma regra, ou o pacote atinja o final da chain. Quando um pacote atinge o final de uma chain sem que tenha casado com alguma regra, é aplicada então a política padrão da chain. Por padrão a política padrão da chain é "ACCEPT" (aceita), mas isso pode ser alterado.

Estados

Como foi dito anteriormente, o netfilter é capaz de reconhecer o estado de uma conexão. Isso além de facilitar a configuração de regras, permite um maior controle sobre o que passa pelo firewall. O netfilter pode atribuir quatro estados para um pacote: NEW, ESTABLISHED, RELATED e INVALID.
Pacotes são classificados como NEW quando são os primeiros pacotes de um fluxo. Quando chega ao firewall a resposta à esse pacote inicial, os pacotes desse fluxo passam a ser identificados como ESTABLISHED. Pacotes que de alguma maneira se relacionam à uma conexão já estabelecida são classificados como RELATED. Ao se fazer uma conexão FTP, por exemplo, é aberto duas conexões: uma onde trafegam dados e outra informações/controle. Essa segunda conexão poderia ser vista pelo netfilter como sendo "RELATED". E por fim pacotes que por alguma razão não foram identificados podem receber o estado de INVALID.

É importante ressaltar que mesmo protocolos não orientados a conexão, como UDP e ICMP podem ser tratados como orientados a conexão pelo firewall. Vejamos o caso do ping, por exemplo. Quando o firewall recebe um pacote ICMP echo request com um determinado ip de origem/destino, esse pacote é marcado como NEW. Ao receber o pacote ICMP echo reply correspondente, os pacotes passam a ser classificados como ESTABLISHED.

A utilização dos estados simplifica bastante a configuração do firewall. Imagine por exemplo que quiséssemos fazer um firewall que permitisse qualquer conexão iniciada pela intranet, mas não permitisse que nenhuma conexão iniciada externamente chegasse a intranet. Bastaria então que permitíssemos pacotes NEW, ESTABLISHED e RELATED vindos da intranet, mas apenas pacotes ESTABLISHED e RELATED vindos da internet.

Configurando um Firewall

Entendido os conceitos expostos, e tendo bem claro o que bloquear e o que não bloquear, fica fácil construir um firewall. A questão "o que bloquear" fica a cargo do administrador de rede, e não trataremos dela aqui.

O comando utilizado para manipular as opções do netfilter chama-se "iptables".

Criando e Removendo Regras

A sintaxe geral para se criar ou remover uma regra é a seguinte:

Código: Selecionar todos
# iptables -[AID] CHAIN [N] [-t TABLE] MATCH -j TARGET


A opção -A é usada para se fazer o "append" de uma regra à uma chain, isto é, a regra será inserida como a última da chain. A opção -I é usada para se inserir uma regra na posição N, e a opção -D é usada para se deletar uma regra. Para deletar podemos simplesmente indicar o número da regra, ou podemos usar as mesmas opções que foram usadas para se criar a regra.

A opção -t admite as 3 tabelas descritas anteriormente. Caso ela não seja definida o iptables considera que a tabela seja a "filter".

As opções que definem o padrão de casamento de uma regra são muitas, como podemos verificar na tabela (incompleta) abaixo:

opção (short): -s
opção (long): --src
parâmetro: X.X.X.X/Y
significado: casa com endereço de origem do pacote

opção (short): -d
opção (long): --dst
parâmetro: X.X.X.X/Y
significado: casa com o endereço de destino do pacote

opção (short): -i
opção (long): --in-interface
parâmetro: interface
significado: casa com a interface pela qual o pacote chegou

opção (short): -o
opção (long): --out-interface
parâmetro: interface
significado: casa com a interace pela qual o pacote vai sair

opção (short): -p
opção (long): --protocol
parâmetro: tcp, udp, icmp
significado: casa com o protocolo do pacote

opção (short): --sport
opção (long): --source-port
parâmetro: porta[:porta]
significado: especifica a porta ou intervalo de portas de origem

opção (short): --dport
opção (long): --destination-port
parâmetro: porta[:porta]
significado: especifica a porta ou intervalo de portas de destino

opção (short): --icmp-type
opção (long):
parâmetro: tipo/código
significado: especifica o tipo de pacote icmp (iptables -p icmp -h para informação)

opção (short): -m
opção (long): --match
parâmetro:
significado: habilita o modo de opções extendido

Além das opções acima, ao se especificar a opção --p PROTOCOL ou --match, poderemos usar mais opções, entre elas:

opção: --limit
parâmetro: X/time
significado: limita a média de matchs. Time pode ser /second, /minute, /hour ou /day

opção: --limit-burst
parâmetro: X
significado: Número máximo inicial de matchs. Esse valor é "recarregado" em 1 a cada intervalo de tempo em que o limite não foi alcançado, até o valor especificado. Utilize essa opção para permitir rajadas.

opção: --mask
parâmetro: X
significado: casa com um pacote "marcado" com o valor X.

opção: --state
parâmetro: NEW,ESTABLISHED, RELATED, INVALID
significado: casa com o estado de uma conexão.

opção: --tcp-flags
parâmetro: MASK FLAGS
significado: Examina as flags "MASK" e casa com FLAGS. Exemplo: SYN,ACK ACK = examina SYN e ACK e casa com pacotes com SYN desligado e ACK ligado.

opção: --tos
parâmetro: nome do serviço
significado: casa com o campo Type of Service. User iptables -m tos -h para ver os nomes/valores

opção: --ttl
parâmetro: valor
significado: casa com o valor do campo ttl do pacote

Uma opção pode ser "negada" se a precedermos com um "!". Assim, por exemplo, ! -s 192.168.0.1/32 casará com qualquer origem. menos com 192.168.0.1/32.

E finalmente devemos especificar o alvo de uma regra. Como cada tabela possui alvos diferentes, com opções diferentes, veremos os alvos agrupados por tabelas:

Tabela filter

alvo: ACCEPT
opções:
significado: Aceita um pacote

alvo: REJECT
opções:
significado: Rejeita um pacote

alvo: REJECT
opções: --reject-with type
significado: Rejeita um pacote e envia um pacote ICMP type para a origem

alvo: DROP
opções:
significado: Descarta silencionsamente o pacote

alvo: LOG
opções:
significado: Loga os headers do pacote

alvo: LOG
opções: --log-level X
significado: Loga utilizando o nível X (veja o arquivo syslog.conf)

alvo: LOG
opções: --log-prefix
significado: permite acrescentar um prefixo de 29 letras. É útil para identificar o tipo pacote/regra

Tabela mangle

alvo: MARK
opções: --set-mark x
significado: marca um pacote com o valor X

alvo: TCPMSS
opções: --set-mss x
significado: ajusta o valor MSS para o valor X

alvo: TOS
opções: --set-tos tos
significado: ajusta o valor do tos. Use iptables -j tos -h para ver os valores possíveis

Tabela nat

alvo: DNAT
opções: --to-destination ipadd[-ipaddr][:port-port]
significado: modifica o destino do pacote - Destination Nat

alvo: MASQUERADE
opções:
significado: o masquerade é um tipo de SNAT, mas é utilizado quando ip do roteador é dinâmico

alvo: REDIRECT
opções: [--to-port]
significado: altera o destino do pacote para a máquina local, opcionalmente altera também a porta de destino

alvo: SNAT
opções: --to-source ipaddr[-ipaddr][:port-port]
significado: altera a origem dos pacotes - Source NAT. opcionalmente altera também as porta de origem

Além dos alvos específicos uma regra pode ter como alvo outra chain. Suponha que tenhamos criado uma chain somente para tratar de pacotes ICMP e tenhamos chamado essa regra de ICMP_FILTER. Poderíamos ter uma regra então na chain FORWARD do tipo:

Código: Selecionar todos
# iptables -A FORWARD -p icmp -j ICMP_FILTER


Pacotes que casassem com a regra acima seriam jogados na chain ICMP_FILTER. Para fazer com que um pacote volte para chain de onde foi encaminhado, utilizamos o alvo "RETURN". Assim, por exemplo, se quiséssemos que pacotes com origem em 192.168.1.1 retornassem a chain FORWARD poderíamos criar a regra:

Código: Selecionar todos
# iptables -A ICMP_FILTER -s 192.168.1.1 -j RETURN


Alguns alvos não são "terminais" ou seja, o netfilter continua percorrendo a chain mesmo que uma regra tenha sido casada. Os alvos LOG, MARK, TCMPSS e TOS são desse tipo.

EXEMPLOS:

Dropa tudo que chegue ao roteador com destino ao host 192.168.0.3:

Código: Selecionar todos
# iptables -A FORWARD -d 192.168.0.3/32 -j DROP


Bloqueia o acesso a porta 23 da máquina local de acessos vindos pela interface eth0:

Código: Selecionar todos
# iptables -A INPUT -i eth0 -p tcp --dport 23 -j REJECT


Loga tentativas de acesso a porta 161 UDP vindas de fora da rede 192.168.0.0/24, limitando o número de match para não encher rapidamente nosso log:

Código: Selecionar todos
# iptables -A FORWARD -p udp --dport 161 ! -s 192.168.0.0/24 -j LOG --limit 1/second


Faz NAT para a rede interna:

Código: Selecionar todos
# iptables -A POSTROUTING -t nat -s 192.168.0.0/24 -o eth1 -j SNAT --to-source 200.X.X.36


Supondo que tenhamos um proxy rodando na máquina, e queremos fazer um proxy "transparente":

Código: Selecionar todos
# iptables -A PREROUTING -p tcp --dport 80 -s 192.168.0.0/24 -j REDIRECT --to-port 3128


Supondo que tenhamos dois servidores dentro da nossa intranet (ip inválido) e queremos balancear as conexões entre os dois:

Código: Selecionar todos
# iptables -A PREROUTING -p tcp --dport 80 -i eth0 -j DNAT --to-source 192.168.1.5,192.168.1.6


Marcando um pacote. Essa marca poderá ser utilizada depois por um outro filtro.

Código: Selecionar todos
# iptables -A PREROUTING -s 192.168.1.5 -j MARK --set-mark 5


Casando pacotes com determinada marca:

Código: Selecionar todos
# iptables -A FORWARD --match --mark 5 -j ACCEPT


Listando Regras

Para se listar o contéudo de uma chain basta utilizar o comando iptables -L [CHAIN] [table]. Lembrando que quando não especificado nenhuma tabela, o padrão é mostar a tabela filter. Exemplos:

Mostra todas as chains da tabela filter:

Código: Selecionar todos
# iptables -L


Mostrando todas as chains da tabela mangle:

Código: Selecionar todos
# iptables -L -t mangle


Mostrando a chain PREROUTING da tabela nat:

Código: Selecionar todos
# iptables -L PREROUTING -t nat


Uma opção muito útil ao se listar chains é o "-v". Utilizando essa opção é mostrado quantos pacotes e quantos bytes percorreram cada chain/regra.

Criando e Removendo Chains

Chains de usuárias são muito utéis quando a quantidade de regras do firewall é grande. Imagine que tenhamos 30 regras para pacotes TCP, mais 20 para pacotes UDP e 10 regras para pacotes ICMP. Um pacote que não case com nenhuma dessas regras percorreria 60 regras! Para evitar isso poderíamos criar chains específicas para cada protolo. Para se criar um chain de usuário basta utilizar o comando:

Código: Selecionar todos
# iptables -t tabela -N chain_do_usuario


Para se remover uma chain usamos:

Código: Selecionar todos
# iptables -t tabela -X chain


Ou para remover todas as chains criadas pelo usuário:

Código: Selecionar todos
# iptables -X


Limpando Chains

Já vimos como remover regras individualmente de uma chain usando a opção "-D", mas e se quiséssemos remover todas as regras de uma chain? Bastaria utilizar a comando:

Código: Selecionar todos
# iptables - F chain -t table


**************************************************************************************************************************

Mini tutórial de IP tables:

Comandos do iptables

-A cadeia – Anexa regras ao final de uma cadeia. Se um nome de host é fornecido, como fonte ou como destino, uma regra é adicionada para cada IP relacionado a este host.
-D cadeia – Apaga uma ou mais regras da cadeia especificada
-D cadeia regra_num – Apaga a regra residente na posição indicada por regra_num da cadeia especificada. A primeira regra na cadeia é a de número 1.
-R cadeia regra_num – Substituí a regra regra_num da cadeia especificada pela regra dada
-I cadeia regra_num – Insere uma ou mais regras no começo da cadeia. Se um nome de host é fornecido, como fonte ou como destino, uma regra é adicionada para cada IP relacionado a este host.
-L [cadeia] – Lista todas as regras em uma cadeia. Caso não haja nenhuma cadeia especificada, todas as regras em todas as cadeias são listadas.
-F [cadeia] – Remove todas as regras de uma cadeia. Se nenhuma cadeia for especificada, remove as regras de todas as cadeias existentes, inclusive as do usuário.
-Z [cadeia] – Restaura os contadores de datagramas e de bytes em todas as regras das cadeias especificadas para zero, ou para todas as cadeias se nenhuma for especificada.
-N cadeia – Cria uma cadeia definida pelo usuário com o nome especificado.
-X [cadeia] – Apaga a cadeia definida pelo usuário ou todas se não for especificada uma.
-C cadeia – Verifica o datagrama descrito pela regra especificada contra a cadeia especificada. Este comando retorna uma mensagem descrevendo como a cadeia processou o datagrama. Isto é muito útil para testar a configuracão do firewall, e para uma análise posterior.
-P cadeia política – Define a política padrão para uma cadeia dentro de uma política especificada. As políticas válidas: ACCEPT, DROP, QUEUE e RETURN. ACCEPT permite a passagem do datagrama. DROP descarta o datagrama. QUEUE passa o datagrama para área do usuário para posterior processamento. RETURN força o código do firewall a retornar para a cadeia anterior e continua o processamento na regra seguinte à que retornou.


Regras

As seguintes regras podem ser usadas:

-p[!] Protocol – Define o protocolo ao qual a regra se aplica. O parâmetro protocol pode ser qualquer valor numérico do arquivo /etc/protocol ou uma das palavras chave: tcp,udp ou icmp
-s [!] addres[/mask] – Define a origem do pacote ao qual a regra se aplica. O parâmetro address pode ser um nome de host, um nome de rede ou um endereço IP com uma máscara de rede opcional.
-d [!] address[/mask] – Define o destino do pacote ao qual a regra se aplica. O endereço e a porta são definidos usando-se as mesmas regras utilizadas para definir esses valores para a origem do pacote.
-j alvo – Define um alvo para o pacote caso ele se encaixe nesta regra. Os alvos possíveis são ACCEPT, DROP, QUEUE ou RETURN. É possível especificar uma cadeia do usuário. Também é possível especificar uma extensão.
-i [!] interface_name – Define o nome da interface por onde o datagrama foi recebido. Um nome de interface parcial pode ser usado encerrando-o com um sinal de “+”; por exemplo, eth+ corresponderia a todas as interfaces Ethernet iniciadas com eth.
-o [!] interface_name – Define o nome da interface por onde o datagrama será transmitido.
[!] -f – Indica que a regra somente se refere ao segundo fragmento e aos subseqüentes de pacotes fragamentados.
Observação: O símbolo “!” é usado na regras como uma negação da expressão. Exemplo: -s 192.168.0.10/32 equivale ao endereço de origem 192.168.0.10, -s !192.168.0.10/32 equivale a todos os endereços exceto o 192.168.0.10.


Opções

-v – Saída em modo verbose. Mais rico em termos de detalhes sobre o que está acontecendo ou sendo feito.
-n – Saída em modo numérico e não por nome de host, rede ou porta.
-x – Exibe o valor exato do pacote e dos contadores de bytes em vez de arrendondá-los para o milhar, milhão ou bilhão mais próximo.
--line-numbers – Quando lista as regras, adiciona um número de linha ao começo de cada regra, correspondendo à posição da regra dentro da cadeia.

Extensões

O utilitário iptables é extensível através de uma biblioteca de módulo compartilhados opcional. Para fazer uso das extensões é preciso especificar o seu nome usando o parâmetro –m [argumento] para o que o iptables carregue este módulo.

Em alguns casos é usuado o parâmetro –p para determinar o protocolo (em certos casos não é necessário o parâmetro –m pois ele é carregado automaticamente, por exemplo quando se usa tcp, udp ou icmp).

Extensão TCP: usada com –m tcp –p tcp

--sport [!] [port[:port]] – Especifica a porta que a origem do datagrama usa. Portas podem ser especificadas com um conjunto especificando-se o seu limite superior e inferior separados por dois pontos (:). Por exemplo, 20:25 descreve todas as portas numeradas de 20 até 25 inclusive. Também é possível usar o caracter “!” para inverter a expressão.

--dport [!] [port[:port]] – Especifica a porta que o destino do datagrama usa.

--tcp-flags [!] mask comp – Especifica que esta regra somente será validada quando os flags do datagrama TCP coincidirem com o especificado em mask e comp. Mask é uma lista separada por vírgulas dos flags que devem ser examinados quando for feito o teste. Comp é uma lista separada por vírgulas dos flas que devem ser configurados. Os flags válidos são: SYN, ACK, FIN, RST, URG, PSH, ALL ou NONE.

--syn – Especifica que a regre deve encontrar somente datagramas com o bit SYN ligado e os bits ACK e FIN desligados. Datagramas com essas opções são usados para requisitar início de conexão TCP.

Extensão UDP: usada com –m udp –p udp

--sport[!][port[:port]] – Este parâmetro tem funcionamento idênyico ao da extensão TCP.

--dport[!][port[:port]] – Este parâmetro tem funcionamento idêntico ao da extensão TCP.

Extensão ICMP: usada com –m icmp –p icmp

--icmp-type [!] typername – Especifica o tipo de mensagem ICMP que a regra deve satisfazer. O tipo pode ser determinado por um número ou nome. Alguns nomes válidos são: echo-request, echo-reply, source-quench, time-exceeded, destionation-unreachable, network-unreachable, host-unreanchable, protocol-unreachable e port-unreachable.

Extensão MAC: usada com –m mac

--mac-source [!] address – Especifica o endereço Ethernet do host que transmitiu o datagrama que esta regra deve encontrar.


Proteção contra IP Spoofing

– O IP Spoofing é uma técnica de forjar endereços IP falsos para executar ataques a uma máquina na web. Geralmente utilizam-se IP falsos nas redes 10.0.0.0, 172.16.0.0 e 192.168.0.0. Para bloquear estes endereços:

Para máquinas com interface de rede:

# iptables –A INPUT –s 10.0.0.0/8 –i eth0 –j DROP

# iptables –A INPUT –s 172.16.0.0/8 –i eth0 –j DROP

# iptables –A INPUT –s 192.168.0.0/8 –i eth0 –j DROP

Para máquinas com interface com modens ADSL:

# iptables –A INPUT –s 10.0.0.0/8 –i ppp0 –j DROP

# iptables –A INPUT –s 172.16.0.0/8 –i ppp0 –j DROP

# iptables –A INPUT –s 192.168.0.0/8 –i ppp0 –j DROP

Para garantir a navegação do nosso equipamento:

# iptables –A INPUT –m state –state RELATED, ESTABLISHED –j ACCEPT



Sem este comando, a estação não navegaria. O módulo ip_conntrack permite especificar regras de acordo com o estado da conexão do pacote. Isto é feito através do parâmetro –state.

NEW – Confere os pacotes que estabelecem novas conexões.

ESTABLISHED – Confere os pacotes com conexões já estabelecidas.

RELATED – Confere com pacotes relacionados indiretamente a uma conexão, como mensagens de erro.

INVALID – Confere com pacotes que não puderem ser identificados por algum motivo. Como respostas de conexão desconhecidas.

Registrar conexões a portas não autorizadas – É importante sabermos quando estamos sendo monitorados, a fim de prever e se defender de possíveis ataques. Para isso podemos fazer com que o iptables registre no messages do Linux tentativas de conexão a portas bloqueadas no sistemas.

# iptables –A INPUT –s 0.0.0.0/0 –i eth0 –j LOG –log-prefix “Conexão proibida”

Se quisermos fechar algumas portas especificamente:

# iptables –A INPUT –p tcp –dport 21 –j LOG –log-prefix “Serviço: ftp”

# iptables –A INPUT –p tcp –dport 23 –j LOG –log-prefix “Serviço:telnet”

O tamanho da mensagem para o parâmetro –log-prefix é de 64 caracteres.

Filtrar mensagem echo-request do ping ou traceroute – Através do comando ping, podemos descobrir qual o sistema operacional está executando num servidor. De posse desta informação, é possível programas ataques e explorações direcionados para este sistema. Caso não queiramos que alguém execute um ping na nossa máquina.

# iptables –A INPUT –p icmp –icmp-type echo-request –j DROP

**************************************************************************************************************************

Montando ou Aperfeiçoando um Firewall com Iptables ...

Aviso importante:

Esse tutorial serve apenas exemplo de comandos iptables para quem quer apreender. Isso é muito válido.
90% desses comandos o BrazilFW JÁ FAZ internamente de acordo com o que você configura.

Você não precisa colocar nada disso no BrazilFW para tem um firewall seguro e com bom funcionamento.
A proposta desse tutorial seria ensinar a configurar um linux comum, partindo do zero, o que não é o nosso caso.


Catando um comando aqui e outro alí na web, juntei esses Iptables que podem ser colocados nas Configurações Personalizadas do Firewall. Espero estar ajudando. Podemos assim melhorar o Firewall do nosso Linux, deixando ele "mais inteligente" e preparado p/ bloquear vários tipos de ataques.

Segue abaixo os Iptables que configurei em cima do meu firewall. Quem tiver mais sugestões Iptables mandem a tona, porque assim somaremos diversos comandos e teremos um firewall de responsa.
------------------------------------------------------------------------------------------------------------------------------------

# Protegendo contra Syn-flood e ataque DoS
iptables -A FORWARD -p tcp --syn -m limit --limit 1/s -j ACCEPT

# Protegendo contra Port Scanners (nmap)
iptables -A FORWARD -p tcp --tcp-flags SYN,ACK,FIN,RST -m limit --limit 1/s -j ACCEPT
iptables -A FORWARD -p tcp --tcp-flags ALL SYN,ACK -j DROP

# Protegendo contra o Ping-of-dead e o Ping
iptables -A FORWARD -p icmp --icmp-type echo-request -m limit --limit 1/s -j ACCEPT
iptables -A FORWARD -p icmp --icmp-type echo-request -j DROP

# Protegendo contra IP Spoofing
iptables -A INPUT -s 10.0.0.0/8 -i $IF_INET -j DROP
iptables -A INPUT -s 172.16.0.0/16 -i $IF_INET -j DROP
iptables -A INPUT -s 192.168.0.0/24 -i $IF_INET -j DROP

#Bloqueando pacotes fragmentados
iptables -A INPUT -i INTEXT -m unclean -j log_unclean
iptables -A INPUT -f -i INTEXT -j log_fragment

#Anulando as respostas a ICMP 8 (echo reply), bloqueia requisições de ping externo
echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_all

#Bloqueando tracertroute
iptables -A INPUT -p udp -s 0/0 -i eth1 --dport 33435:33525 -j DROP

#Protecoes contra ataques
iptables -A INPUT -m state --state INVALID -j DROP

#proteção contra pacotes danificados ou suspeitos.
iptables -A FORWARD -m unclean -j DROP

#Bloqueando ping de um ip
iptables -A INPUT -p icmp -s 192.168.1.1/24 -j DROP

# Acelerando sua conexão
iptables -t mangle -A OUTPUT -p tcp -j TOS --sport 80 --set-tos 0x08
iptables -t mangle -A PREROUTING -p tcp --dport 80 -j TOS --set-tos 0x08
iptables -t mangle -A OUTPUT -p tcp -j TOS --sport 80 --set-tos 0x10



Agora, Iptables q podem ser úteis a situações diversas...
---------------------------------------------------------------------------------------------------------------

:arrow: Exemplos comentados de regras de firewall (tabela filter)
---------------------------------------

#Lista todas as regras existentes.
iptables -L
---------------------------------------

#Apaga todas as regras sem alterar a política.
iptables -F
---------------------------------------

#Estabelece uma política de proibição inicial de passagem de pacotes entre sub-redes.
iptables -P FORWARD DROP
---------------------------------------

#Todos os pacotes oriundos de qualquer sub-rede e destinados a qualquer sub-rede deverão ser descartados.
iptables -A FORWARD -j DROP
---------------------------------------

#Todos os pacotes oriundos de qualquer sub-rede e destinados a qualquer sub-rede deverão ser aceitos.
iptables -A FORWARD -j ACCEPT
---------------------------------------

#Os pacotes oriundos da sub-rede 10.0.0.0 (máscara 255.0.0.0) e destinados ao host http://www.chat.com.br deverão ser descartados.
iptables -A FORWARD -s 10.0.0.0/8 -d http://www.chat.com.br -j DROP
---------------------------------------

#Os pacotes oriundos da sub-rede 10.0.0.0 (máscara 255.0.0.0) e destinados ao host http://www.chat.com.br deverão ser descartados. Deverá ser enviado um ICMP avisando à origem.
iptables -A FORWARD -s 10.0.0.0/8 -d http://www.chat.com.br -j REJECT
---------------------------------------

#Os pacotes oriundos de qualquer lugar e destinados ao host http://www.chat.com.br deverão ser descartados.
iptables -A FORWARD -d http://www.chat.com.br -j DROP
---------------------------------------

#Os pacotes destinados à sub-rede 10.0.0.0 (máscara 255.0.0.0) e oriundos do host http://www.chat.com.br deverão ser descartados.
iptables -A FORWARD -d 10.0.0.0/8 -s http://www.chat.com.br -j DROP
---------------------------------------

#Os pacotes oriundos do host http://www.chat.com.br e destinados a qualquer lugar deverão ser descartados.
iptables -A FORWARD -s http://www.chat.com.br -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 200.221.20.0/24 -j DROP
---------------------------------------

#Os pacotes icmp oriundos do host 10.0.0.5 e destinados a qualquer lugar deverão ser descartados.
iptables -A FORWARD -s 10.0.0.5 -p icmp -j DROP
---------------------------------------

#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 -i ! eth0 -j ACCEPT
---------------------------------------

#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 -s 10.0.0.5 -p tcp --sport 80 -j LOG
---------------------------------------

#Os pacotes TCP destinados à porta 25 de qualquer host deverão ser aceitos.
iptables -A FORWARD -p tcp --dport 25 -j ACCEPT
---------------------------------------

:arrow: Exemplos comentados de regras de firewall (tabela nat)
---------------------------------------

#iptables -t nat -L
Mostra as regras de NAT ativas.
---------------------------------------

#iptables -t nat -F
Apaga todas as regras de NAT existentes.
---------------------------------------

#iptables -t nat -A POSTROUTING -o ppp0 -j MASQUERADE
Todos os pacotes que saírem pela interface ppp0 (modem) serão mascarados. Isso dá um nível de segurança elevado à rede que está atrás da ppp0. É uma boa regra para navegação na Internet. Note que esse tipo de mascaramento não usa SNAT.
---------------------------------------

#iptables -t nat -A POSTROUTING -d 0/0 -j MASQUERADE
Tem o mesmo efeito da regra anterior. No entanto, parece ser menos segura, pois estabelece que qualquer pacote destinado a qualquer outra rede, diferente da interna, será mascarado. A regra anterior refere-se aos pacotes que saem por determinada interface. A opção -d 0/0 poderia ser -d 0.0.0.0/0 também. É uma outra regra para navegação na Internet.
---------------------------------------

#iptables -t nat -A PREROUTING -t nat -p tcp -d 10.0.0.2 --dport 80 -j DNAT --to 172.20.0.1
Redireciona todos os pacotes destinados à porta 80 da máquina 10.0.0.2 para a máquina 172.20.0.1. Esse tipo de regra exige a especificação do protocolo. Como não foi especificada uma porta de destino, a porta de origem (80) será mantida como destino.
---------------------------------------

#iptables -t nat -A OUTPUT -p tcp -d 10.0.0.10 -j DNAT --to 10.0.0.1
Qualquer pacote TCP, originado na máquina firewall, destinado a qualquer porta da máquina 10.0.0.10, será desviado para a máquina 10.0.0.1 .
---------------------------------------

#iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to 200.20.0.1
Essa regra faz com que todos os pacotes que irão sair pela interface eth0 tenham o seu endereço de origem alterado para 200.20.0.1 .
---------------------------------------

#iptables -t nat -A PREROUTING -i eth0 -j DNAT --to 172.20.0.1
Todos os pacotes que entrarem pela eth0 serão enviados para a máquina 172.20.0.1 .
---------------------------------------

#iptables -t nat -A PREROUTING -i eth0 -j DNAT --to 172.20.0.1-172.20.0.3
Aqui haverá o load balance. Todos os pacotes que entrarem pela eth0 serão distribuídos entre as máquinas 172.20.0.1 , 172.20.0.2 e 172.20.0.3 .
---------------------------------------

#iptables -t nat -A PREROUTING -s 10.0.0.0/8 -p tcp --dport 80 -j REDIRECT --to-port 3128
Todos os pacotes TCP que vierem da rede 10.0.0.0, com máscara 255.0.0.0, destinados à porta 80 de qualquer host, não sairão; serão redirecionados para a porta 3128 do firewall. Isso é o passo necessário para fazer um proxy transparente. O proxy utilizado deverá aceitar esse tipo de recurso. No caso, o Squid, que aceita transparência, deverá estar instalado na máquina firewall, servindo na porta 3128.
---------------------------------------

#iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth1 -j SNAT 200.20.5.0/24
Uma situação interessante: todos os pacotes que saírem da rede 192.168.1.0 serão transformados em 200.20.5.0 .
---------------------------------------

:arrow: Uma rede na Internet

Vamos permitir que a rede 10.0.0.0 navegue na Internet. A máquina firewall será a 10.0.0.1. Regras:

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

O procedimento é totalmente seguro, pois discrimina uma origem, que só poderá sair pela ppp0, de forma mascarada.
-----------------------------------------------------------------------

:arrow: Alguns hosts na Internet

Vamos permitir que alguns hosts, no caso, o 10.0.0.10, o 10.0.0.20 e o 10.5.2.41, naveguem na Internet. A máquina firewall será a 10.0.0.1. Regras:

#echo 1 > /proc/sys/net/ipv4/ip_forward
#modprobe iptable_nat
#iptables -t nat -A POSTROUTING -s 10.0.0.10 -o ppp0 -j MASQUERADE
#iptables -t nat -A POSTROUTING -s 10.0.0.20 -o ppp0 -j MASQUERADE
#iptables -t nat -A POSTROUTING -s 10.5.2.41 -o ppp0 -j MASQUERADE
---------------------------------------------------------------------------------------------------

:arrow: Execução de FTP
Para executar sessões de FTP, será necessário o carregamento de dois módulos:

#insmod ip_conntrack_ftp
#insmod ip_nat_ftp
--------------------------------------------------------------------------------------------------

:arrow: Outros iptables

Nas linhas abaixo, algumas regras que são comumente utilizadas.
Algumas destas podem ser úteis para fazer o seu firewall mas lembre-se de adaptá-las para sua rede/interface/máquina antes de aplicá-las:

#Libera o apache pra web
iptables -A INPUT -p tcp --destination-port 6080 -j ACCEPT
iptables -A INPUT -p tcp --destination-port 443 -j ACCEPT

#Libera o loopback
iptables -A OUTPUT -p tcp --syn -s 127.0.0.1/255.0.0.0 -j ACCEPT

#Bloqueando todos os endereços vindo de uma determinada rede para a minha máquina
iptables -A INPUT -s 10.0.0.0/8 -j DROP

#Liberando o endereço vindo de uma rede para a minha máquina
iptables -A INPUT -s 10.0.0.1 -j ACCEPT

#Gerando Logs de Portas proibidas
iptables -A INPUT -p tcp --dport 21 -j --log-prefix "Serviço de FTP"

#Gerando log de Backdoors
iptables -A INPUT -p tcp --dport 5042 -j LOG -log-prefix "Wincrash"
iptables -A INPUT -p tcp --dport 12345 -j LOG -log-prefix "backOrifice"
iptables -A INPUT -p tcp --dport 12346 -j LOG -log-prefix "backOrifice"

#Habilitando porta de FTP
iptables -A INPUT -p tcp -s 192.168.0.45 --dport 21 -j ACCEPT

#Habilitando porta de SSH
iptables -A INPUT -p tcp -s 192.168.0.45 --dport 22 -j ACCEPT

#Habilitando porta de SMTP
iptables -A INPUT -p tcp -s 192.168.0.45 --dport 25 -j ACCEPT

#Habilitando porta de DNS
iptables -A INPUT -p tcp -s 192.168.0.45 --dport 53 -j ACCEPT

#Habilitando porta de POP3
iptables -A INPUT -p tcp -s 192.168.0.45 --dport 110 -j ACCEPT

#Habilitando porta de DNS (UDP)
iptables -A INPUT -p udp -s 192.168.0.45 --source-port 53 -j ACCEPT

#Redirecionar Porta
iptables -t nat -A PREROUTING -s IP_NET -i EXT_INT -j DNAT --to IP_DESTINO
iptables -t nat -A POSTROUTING -s IP_NET -o EXT_INT -p tcp --dport PORT -j ACCEPT
iptables -t nat -A POSTROUTING -s IP_DESTINO -o EXT_INT -j SNAT --to IP_NET
iptables -t nat -A POSTROUTING -s IP_DESTINO -o EXT_INT --p tcp --dport PORT -j ACCEPT

IP_NET = IP válido da internet.
EXT_INT = Interface da Internet.
IP_DESTINO = IP inválido da Internet ou melhor ip da rede que vai fazer redirecionamento.
PORT = porta

#Fazendo redirecionamento de portas
iptables -t nat -A PREROUTING -i FACE -p tcp --dport 80 -j REDIRECT --to-port 3128

FACE = interface de rede

#Bloqueando todos os pacotes originários da rede 10.0.0.0 para o host http://www.seila.com.br
iptables -A FORWARD -s 10.0.0.0/8 -d http://www.seila.com.br -j DROP

#Liberando todos os pacotes originários da rede 10.0.0.0 para o host http://www.seila.com.br
iptables -A FORWARD -s 10.0.0.0/8 -d http://www.seila.com.br -j ACCEPT

#Liberando todos os pacotes tcp destinados a porta 25
iptables -A FORWARD -p tcp --dport 25 -j ACCEPT

#Liberando acesso interno da rede
iptables -A INPUT -p tcp --syn -s 192.168.1.0/24 -j ACCEPT
iptables -A OUTPUT -p tcp --syn -s 192.168.1.0/24 -j ACCEPT
iptables -A FORWARD -p tcp --syn -s 192.168.1.0/24 -j ACCEPT

#compartilhando a web na rede interna
iptables -t nat -A POSTROUTING -s 192.168.1.0/255.255.255.0 -o eth1 -j MASQUERADE
echo 1 > /proc/sys/net/ipv4/ip_forward &&

#Libera Bittorrent somente para esta maquina
iptables -A INPUT -p tcp --destination-port 6881:6889 -j ACCEPT

#Bloqueando uma máquina pelo endereço MAC
iptables -A INPUT -m mac --mac-source XX:XX:XX:XX:XX:XX -j DROP

# Regras para bloquear Kazaa, Morpheus, iMesh, Grokster, eDonkey, eMule, DC++, etc:
iptables -t mangle -A POSTROUTING -m layer7 --l7proto fasttrack -j DROP
iptables -t mangle -A POSTROUTING -m layer7 --l7proto edonkey -j DROP
iptables -t mangle -A POSTROUTING -m layer7 --l7proto directconnect -j DROP

# Liberando a máquina de ip 192.168.0.4 de utilizar proxy
iptables -t nat -A PREROUTING -i eth0 -p tcp -s 192.168.0.4 --dport 80 -j ACCEPT

# e definindo que as outras máquinas devem utilizar proxy
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 8080

# a regra abaixo também define que a máquina com um ip expecífico deve utilizar o proxy (no caso ip 192.168.0.6)
iptables -t nat -A PREROUTING -i eth0 -p tcp -s 192.168.0.6 --dport 80 -j REDIRECT --to-port 8080

#Fechar a Máquina Filtro de Pacotes com Iptables, de modo que todas os pacotes destinados diretamente a ela sejam descartados.
iptables -P INPUT DROP

#A linha abaixo determina que todos os pacotes destinados à máquina 192.168.1.1 devem ser descartados.
iptables -A FORWARD -d 192.168.1.1 -j DROP


:arrow: Topologias de firewall

O posicionamento de um firewall dentro da rede é de extrema importância para ela. Há duas possibilidades básicas para a utilização de um firewall: firewall isolado e firewall incorporado, sendo este último o mais inseguro e menos desejável.

O firewall será isolado quando estiver entre máquinas, com função exclusiva de firewall:

O firewall será incorporado quando não houver uma máquina isolada como firewall. Nesse caso, as máquinas da rede deverão estabelecer, individualmente, as suas próprias regras de firewall. É o sistema mais inseguro:

Nada impede que os dois sistemas sejam utilizados em parceria. Cabe ressaltar que no firewall incorporado há maior nível de insegurança, uma vez que outros processos rodam junto com o firewall.

:arrow: Site de exemplo para testes de segurança e antivírus.

http://security.symantec.com/sscv6/home ... RMN&bhcp=1


:arrow: Site de exemplo para testes de antivírus, só entrem com o antivírus atualizado. normalmente tem vírus na página inicial.
http://cracks.am
Contribua para que o Projeto BFW permaneça no ar, Doe Click aqui
Contribua com o reginaldo, Doe, favor enviar e-mail para reginaldo@brazilfw.com.br
-----------------------------------------------------------------------------------------------------
"Disciplina é liberdade. Compaixão é fortaleza. Ter bondade é ter coragem" (Há Tempos [Dado Villa-Lobos/Renato Russo/Marcelo Bonfá])
Avatar do usuário
reginaldo
BFW Mediator
BFW Documenter
BFW Manager
BFW 3.x Update
 
Mensagens: 12682
Registrado em: Sáb Ago 27, 2005 12:10 pm
Localização: Rio de Janeiro - RJ
BrazilFW Box: Máquina Física
CPU: Intel Core i3 Model 530
Memória: 8.00 GiB / 2 Links
BFW 3.0.262 64 bits
Serviços Ativos: Control MAC, QOS
Addons: EBackup, EPM e Squid 3.5.x

Voltar para Tutoriais Diversos

Quem está online

Usuários navegando neste fórum: Nenhum usuário registrado e 0 visitantes