Firewall Linux

From Prof. Vinicius Vieira
Jump to navigation Jump to search

Defesa em profundidade com Linux


Firewall IPTables - Introdução teórica

Os sistemas GNU/Linux com Kernel série 2.4 e 2.6 em diante, trabalham com o “Iptables” para fazer o gerenciamento de regras de firewall. Lembrando que o “Iptables” é apenas um “frontend” que gerencia o suporte “Netfilter” no “Kernel”. O “Iptables” possui 4 tabelas, sendo elas:


   • filter – Como o nome sugere, trata-se de uma tabela de controle de conteúdo dos pacotes.
   • Nat – Esta tabela é utilizada no compartilhamento de conexões, permitindo que redes internas roteiem e possam acessar a Internet, por exemplo.
   • Mangle – Tabela de configurações especiais e auxiliares dos mecanismos de filtro e roteamento de pacotes.
   • Raw – Tabela usada para configurar exceções do rastreamento de conexões do Kernel. Esse mecanismo é também conhecido como: “connection tracking”.


OBS: A tabela “filter” é a tabela padrão do “iptables”


Cada uma dessas tabelas possui o que chamamos de “chains”. É nelas onde vão ser definidas as regras para o nosso “firewall”. A tradução literal seria “correntes”, assim cada tabela teria uma corrente, onde cada elo corresponderia a uma regra. Nesse capítulo vamos tratar mais das “chains” da tabela “filter” e algo sobre as “chains” da tabela “nat”.

As “chains” da tabela “filter” são as seguintes:

Tabela Filter

   • INPUT- Regras de entrada de pacotes
   • OUTPUT  - Regras de saída de pacotes
   • FORWARD - Regras de passagem de pacotes pelo “firewall”.

As “chains” da tabela “nat” são as seguintes:

Tabela Nat

   • PREROUTING   - Regras que serão processadas antes do roteamento dos pacotes nas interfaces do “firewall”.
   • POSTROUTING - Regras que serão processadas após o roteamento dos pacotes nas interfaces do “firewall”.
   • OUTPUT  - Regras de saída de pacotes.


Compreendendo as politicas básicas e o conceito das exceções

A metodologia utilizada para implementação do “firewall” será a seguinte:

     EXCEÇÕES – CONTROLES – POLÍTICAS BÁSICAS

Iremos negar todo o tráfego para as “chains” de “INPUT”, “OUTPUT” e “FORWARD” da tabela “filter”, posteriormente iremos definir a relação dos serviços que devem ser liberados no “firewall”, a estes, iremos chamar de exceções. Todo o tráfego de pacotes que as nossas exceções não cobrirem será bloqueado por padrão. Em suma, o que não for oficialmente permitido já está expressa e previamente negado. Perceba que as “chains” são descritas em letras maiúsculas.


Prática Dirigida

Vamos montar nosso laboratório. No link https://goo.gl/3pMidG disponibilizamos uma VM em OVA que você deve importar para o seu VirtualBox (login root senha 123456). Ela está configurada com placa de rede em modo bridge, logo ela irá pegar um IP da sua rede interna e terá o mesmo gateway que sua máquina Física.


Verifique como estão configuradas as políticas básicas que estão definidas por padrão:

iptables -n -L


Modifique as políticas básicas para “DROP ALL”:

iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP


Verifique se a nova política foi assumida:

iptables -n -L


Agora que percebemos que temos um “firewall” ativo, devemos pensar nas demais políticas, uma vez que, por mais seguro que seja a política de “negar tudo”, não é prático manter nosso computador assim. Ele precisará se comunicar com outro computadores e para que isso seja possível, precisamos definir políticas de exceções.


Realize o teste usando o comando “ping” na sua interface “Ioopback”:

ping 127.0.0.1


O teste anterior nos permitiu verificar que devemos definir uma política de exceções para a interface “Ioopback”. Criaremos uma política que possibilite isso:

iptables -A OUTPUT -d 127.0.0.1 -j ACCEPT
iptables -A INPUT -d 127.0.0.1 -j ACCEPT

Liste as políticas ativas:

iptables -n -L


Vejamos se agora conseguimos fazer um “ping” na interface de “Ioopback”:

iptables 127.0.0.1


Execute o comando “ping”, tendo como alvo e endereço da sua máquina física (para saber o seu IP rode o comando "ifconfig" ou "ip a"):

ping [ip-da-sua-máquina-física]


Agora criaremos uma politica que autorize enviar e receber pacotes ICMP, permitindo o firewall executar e responder requisições de ping:


iptables -A OUTPUT -p icmp -s ip-do-firewall -d 0/0 -j ACCEPT
iptables -A INPUT -p icmp -s 0/0 -d ip-do-firewall -j ACCEPT


Verifique se as regras foram adicionadas:

iptables -n -L


Podemos ver se conseguimos fazer um “ping” em outra máquina da rede:

ping [ip-da-sua-máquina-física]


Agora que já temos um política de exceção, tente fazer um “ping” no domínio “www.uol.com.br”:

ping www.uol.com.br


Apesar de conseguirmos usar o “ping” nos endereços IP's, ainda não conseguimos fazer um “ping” por nomes. Vamos desenvolver a regra que faça isso:

iptables -A OUTPUT -p udp -s ip-do-firewall –sport 1024:65535 -d 0/0 –dport 53 -j ACCEPT
iptables -A INPUT -p udp -s 0/0 –sport 53 -d ip-do-firewall –dport 1024:65535 -j ACCEPT 


Verifique se as regras foram adicionadas:

iptables -n -L


Com as regras definidas, podemos fazer um “ping” por nomes:

ping www.uol.com.br


OBS: Mesmo que liberemos o nosso “firewall” para resolver os nomes, ainda não conseguiremos acessar um servidor Web, pois precisamos liberar o acesso as portas 80 e 443.


Criaremos uma regra de exceção que permita navegação web:

iptables -A OUTPUT -p tcp -s ip-do-firewall --sport 1024:65535 -d 0/0 –dport 80 -j ACCEPT
iptables -A OUTPUT -p tcp -s ip-do-firewall –sport 1024:65535 -d 0/0 –dport 443 -j ACCEPT
iptables -A INPUT -p tcp -s 0/0 –sport 80 -d ip-do-firewall –dport 1024:65535 -j ACCEPT
iptables -A INPUT -p tcp -s 0/0 –sport 443 -d ip-do-firewall –dport 1024:65535 -j ACCEPT

Firewall como “gateway” de rede

Se o nosso servidor é, por exemplo, um “firewall” de fronteira entre a sua rede e a internet, ou seja, um “gateway” de rede, devemos estabelecer uma política que faça o repasse dos pacotes de uma rede para outra, para permitir o repasse (forward) de pacotes entre uma rede e outra.


A primeira coisa que precisamos fazer é liberar o repasse de pacotes entre as interfaces de rede, no Kernel:

sysctl -a | grep ip_forward
sysctl -w net.ipv4.ip_forward=1


OBS: Para deixar esse valor fixo, devemos deixar esse parâmetro dentro de /etc/sysctl.conf

vim /etc/sysctl.conf net.ipv4.ip_forward=1


Agora precisamos permitir no “iptables” que nossa rede se comunique com outras. Devemos fazer isso acrescentando regras na chain FORWARD:

iptables -A FORWARD -s ip-do-firewall/24 -j ACCEPT
iptables -A FORWARD -d ip-do-firewall/24 -j ACCEPT 


Não podemos esquecer que a internet utiliza IP's públicos, diferente da nossa rede. Por isso teremos que fazer a tradução de endereçamento inválido (da LAN) para o válido (da internet), através da especificação da tabela “NAT”, fazendo o mascaramento.


Vamos fazer com que nossa LAN seja mascarada:

iptables -t nat -A POSTROUTING -o ethX -s ip-do-firewall/24 -j MASQUERADE

OBS: A interface ethX é a que está com IP válido.


Verifique como estão as regras inseridas:

iptables -n -L
iptables -n -L -t nat


Para não perdemos essas regras, podemos salvá-las utilizando recursos do “iptables”, lembrando que isso não é ainda um “script” profissional:

iptables-save > /root/firewall.back
cat firewall.back 

Agora podemos fazer um teste e limpar todas as regras adicionadas na memória:

iptables -F
iptables -F -t nat 


Verifique se as regras foram apagadas:

iptables -n -L
iptables -n -L -t nat 


Modifique as políticas básicas para ACCEPT:

iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT 


Script de Firewall

Todas as regras que foram feitas ficam na memória do computador, se ele for reiniciado, perderemos todas elas. Podemos utilizar o “iptables-save”, mas ele não é um “script” profissional.

Segue aqui um script com todos as regras que foram feitas, e em seguida esse “script” pode ser adicionado aos níveis de execução do sistema, para ser carregado sempre que a máquina for ligada.

Vamos chamar nosso script de “firewall.sh”. Use seu editor de textos preferido e crie um script de firewall com os parâmetros abaixo:


#!/bin/bash
    
## Definição de variáveis

# Fechando as Políticas
$IPT -P INPUT DROP

$IPT -P OUTPUT DROP

$IPT -P FORWARD DROP

## Liberando LoopBack
$IPT -A OUTPUT -d 127.0.0.1 -j ACCEPT
$IPT -A INPUT -d 127.0.0.1 -j ACCEPT

## Liberando Ping
$IPT -A OUTPUT -p icmp -s $ETO -d $NET -j ACCEPT 
$IPT -A INPUT -p icmp -s $NET -d $ETO -j ACCEPT 

## Liberando resolução de nomes
$IPT -A OUTPUT -p udp -s $ETO --sport $PA -d $NET --dport 53 -j ACCEPT 
$IPT -A INPUT -p udp -s $NET --sport 53 -d $ETO --dport $PA -j ACCEPT 

## Liberando navegação web
$IPT -A OUTPUT -p tcp -s $ETO --sport $PA  -d $NET --dport 80 -j ACCEPT 
$IPT -A OUTPUT -p tcp -s $ETO --sport $PA -d $NET --dport 443 -j ACCEPT
$IPT -A INPUT -p tcp -s $NET --sport 80 -d $ETO --dport $PA -j ACCEPT 
$IPT -A INPUT -p tcp -s $NET --sport 443 -d $ETO --dport $PA -j ACCEPT


## Liberando consultas mtr
$IPT -A INPUT -p icmp --icmp-type 11 -s $ETO -j ACCEPT


# Regras de FORWARD e NAT para liberar a LAN para acessar a internet.. 
sysctl -w net.ipv4.ip_forward=1
$IPT -A FORWARD -s $REDE -j ACCEPT 
$IPT -A FORWARD -d $REDE -j ACCEPT
$IPT -t nat -A POSTROUTING -o ethX -s $REDE -j MASQUERADE 


OBS: Agora podemos configurar as permissões de execuções para o “script”:

chmod 755 firewall.sh
ls -l firewall.sh 


Para que ele seja iniciado junto com sistema quando a máquina for ligada podemos colocar o “script” nos níveis de execução

update-rc.d firewall.sh defaults
ls -l /etc/rc2.d 


IMPORTANTE: você deve ter reparado no script acima que usamos os argumentos “-i ethX” e “-o ethX”. Mas o que quer dizer isso? O argumento “-i” refere-se a input, ou seja, entrada. E o argumento “-o” refere-se a output, ou seja, saída, onde:

-i ethX = interface de entrada
-o ethX = interface de saída

Material de Apoio

HIDS em Linux

Ips ids hids.jpg NIDS-vs-HIDS.jpg

Tutorial do OSSEC:Media:How_to_Install_OSSEC_HIDS_on_Debian_9.pdf

Ou: acesse aqui

Exercício de Cyber Warfare

Projeto cyberwar 2TDCR.png

Dica:

#iptables -t nat -A PREROUTING -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 80 será mantida como destino.