Módulo Time

O Módulo Time pode ser usado quando queremos tratar os pacotes usando o IPtables, quanto ao tempo, seja em dia ou hora. As regras aplicadas com o Módulo Time são muito interessantes para podermos criar regras vinculadas com horário, como por exemplo, liberar acesso a determinado site ou serviço no horário de almoço.

Para usar o Módulo Time, faz uso da opção "-m", como nos outros módulos e o nome do módulo "time".

- Algumas opções usadas:

• --timestart : Está opção é usada para especificar a partir de que hora a regra será validada. Se não especificada, será: 00:00. Valor em HH:MM.
• --timestop : Está opção é usada para especificar até que hora a regra será validada. Se não for especificada, o valor será: 23:59. valor em HH:MM.
• --weekdays : Está opção especifica em que dias da semana a regra será validada. Os dias são: Mon, True, Wed, Thu, Fri, Sat e Sun.
• --monthdays : Está opção é usada para especificar em que dias do mês a regra será validada, os valores possíveis são 1 a 31, e devem ser colocados assim 2,3. Neste caso, seria o dia 2 até o dia 3.
• --datestart : Está opção é usada para especificar a partir de que data a regra começará a ser validada. Os campos devem ser preenchidos assim: YYYY- MM-DDThh:mm:ss, onde 'YYYY' é o ano, 'MM' é o mês, 'DD' é o dia, 'T' é para indicar o tempo, 'hh' é a hora, 'mm' são os minutos e 'ss' são os segundos.
• --datestop : Está opção é usada para especificar até que data a regra será validada. os campos devem ser preenchidos assim: YYYY-MM- DDThh:mm:ss, onde YYYY é o ano, MM é o mês, DD é o dia, T é para indicar o tempo, hh é a hora, mm são os minutos e ss são os segundos.

- Colocando em Prática

Na primeira regra usada para testar o uso do módulo time, vou bloquear o acesso de um Host 192.168.20.10 da minha rede interna, das 08:00 até as 18:00, todos os dias ao Webmin da máquina local, onde a regra está sendo executada.

# iptables -A INPUT -s 192.168.20.10 -p tcp --dport 10000 -m time --timestart 08:00 --timestop 18:00 -j DROP

Na segunda regra, faço uso do Módulo String que já foi abordado no artigo e bloqueio a String "orkut" para bloquear o site do Orkut, liberando o mesmo somente no horário 12:00 às 14:00 para todos os Hosts.

Mas depois desta regra, coloco outra para bloquear o tráfego com essa String durante o tempo que a primeira regra não faz referência a algum pacote que transite, ou seja, enquanto o período de 12:00 até as 14:00 não chega.

# iptables -A FORWARD -m string --algo bm --string "orkut" -m time --timestart 12:00 --timestop 14:00 -j ACCEPT
# iptables -A FORWARD -m string --algo bm --string "orkut" -j DROP

Na Terceira regra, vou permitir o protocolo P2P (Kaaza, Emulee, etc..) de segunda à sexta no horário de 12:00 às 14:00, nos outros horários e dias, será bloqueado o tráfego.

Obs.: para usar o módulo 'ipp2p', é necessário que o mesmo esteja compilado para o kernel que está usando.

# iptables -A FORWARD -m ipp2p --ipp2p -m time --timestart 12:00 --timestop 14:00 --weekdays Mon,Tue,Wed,Thu,Fri -j ACCEPT
# iptables -A FORWARD -m ipp2p --ipp2p -j DROP

Módulo Limit

O Módulo Limit é um tipo de módulo sempre bem vindo quando se quer mais segurança para evitar que sua rede ou servidores, sejam vitimas de ataques. As regras que fazem uso deste módulo, trabalham com quantidade e tempo.

O módulo permiti especificar o número de vezes em determinado intervalo de tempo que uma regra conferirá quando todas as condições forem satisfeitas.

Por exemplo: "-m limit --limit n/t", onde 'n' é o número de vezes e 't' é o tempo, ou seja, um número 'n' de ocorrências deverá ser verificado em um determinado tempo 't'. Quando este valor for atingido, a próxima regra será executada, o que normalmente é com o alvo DROP.

- As opções usadas são:

• --limit n/t : Está opção permite especificar a taxa de conferências do Limit, onde 'n' é o número de vezes em deverá ocorrer em 't' intervalo de tempo.
  As opções de tempo são:
  
  • s : segundo
  • m : minuto
  • h : hora
  • d : dia
• --limit-burst : Com esta opção, poderemos indicar o número inicial máximo de pacotes que irão conferir, este número é aumentado 1 a cada vez que o "--limit" não for atingido.

A sintaxe é a mesma dos outros módulos, onde '-m' indica que será chamado um módulo seguido do nome do módulo, no caso 'limit' com as opções "--limit n/t" com e, ou "--limit-burst".

* Saiba como utilizar este módulo, pois o mesmo pode fazer que clientes não acessem serviços, caso a regra seja aplicada sem um bom planejamento e uma boa bateria de testes.

- Colocando em Prática

Para testar bem este módulo, primeiro vai ser aplicada uma regra limitando 2 pacotes ICMP (ping) em um intervalo de um minuto, a partir do terceiro ping, no intervalo de um minuto a próxima regra será executada bloqueando os pacotes.

* A máquina com as regras é: 192.168.20.10

# iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit 2/m -j ACCEPT
# iptables -A INPUT -p icmp --icmp-type echo-request -j DROP

- Testando:

# ping -c 6 192.168.20.10
# iptables -nvL

Chain INPUT (policy ACCEPT 6 packets, 1254 bytes)
pkts bytes target prot opt in out source destination
5 420 ACCEPT icmp -- * * 0.0.0.0/0 0.0.050/0 icmp type 8 limit: avg 2/min burst 5
1 84 DROP icmp -- * * 0.0.0.0/0 0.0.0.0/0 icmp type 8

Após o teste, percebemos que saiu algo de errado, pois foi enviado 6 pacotes ICMP para o destino com as regras do IPtables aplicadas e mesmo assim, só foi bloqueado 1, e 5 ICMP passaram, veja na saída do comando:

# iptables -nvL

Que a primeira regra tratou 5 pacotes, permitindo sua passagem. Enquanto que a segunda que era para bloquear 4 dos pacotes bloqueou apenas 1. Por que isso?

A resposta, é que quando usamos o Módulo Limit, automaticamente, é setado um valor que especifica o número inicial de pacotes que irá conferir com a regra, e o valor padrão é 5. Assim sendo, para a regra dar certo, precisamos especificar a opção "--limit-burst" com o número 2, como faço abaixo:

# iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit 2/m --limit-burst 2 -j ACCEPT
# iptables -A INPUT -p icmp --icmp-type echo-request -j DROP

- Testando:

# ping -c 6 192.168.20.10
# iptables -nvL

Chain INPUT (policy ACCEPT 41 packets, 5109 bytes)
pkts bytes target prot opt in out source destination
2 168 ACCEPT icmp -- * * 0.0.0.0/0 0.0.0.0/0 icmp type 8 limit: avg 2/min burst 2
4 336 DROP icmp -- * * 0.0.0.0/0 0.0.0.0/0 icmp type 8

Agora sim, a regra permitiu dois pacotes, e a partir do terceiro, em um intervalo de um minuto bloqueou os outros, no caso 4.

Na regra anterior, usei o intervalo em minuto, porém, nada me impede de usar segundos, mas para a regra acima, seria mais interessante usar em segundos, pois em segundos impede um ataque como o 'ping da morte', então, abaixo coloco as regras em segundos:

# iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit 1/s --limit-burst 1 -j ACCEPT
# iptables -A INPUT -p icmp --icmp-type echo-request -j DROP

- Testando:

# ping -c 10 -i 0.0 192.168.20.10

PING 192.168.20.10 (192.168.20.10) 56(84) bytes of data.
64 bytes from 192.168.20.10: icmp_req=1 ttl=64 time=0.166 ms

--- 192.168.20.10 ping statistics ---
10 packets transmitted, 1 received, 90% packet loss, time 94ms
rtt min/avg/max/mdev = 0.166/0.166/0.166/0.000 ms, ipg/ewma 10.520/0.166 ms

# iptables -nvL

Chain INPUT (policy ACCEPT 159 packets, 112K bytes)
pkts bytes target prot opt in out source destination
1 84 ACCEPT icmp -- * * 0.0.0.0/0 0.0.0.0/0 icmp type 8 limit: avg 1/sec burst 1
9 756 DROP icmp -- * * 0.0.0.0/0 0.0.0.0/0 icmp type 8

Perceba que a regra funcionou muito bem, pois bloqueou 9 pacotes dos 10 enviados, aceitando apenas 1. Pois quando executei o ping, ao invés de usar o intervalo padrão de 1 segundo, usei o intervalo de 0.0 segundos entre o envio de cada pacote, assim ele enviou 10 pacotes em um segundo e a regra aceitou apenas 1, como era previsto.

Na segunda regra, mudei a porta do SSH para 2100, mas isso não adianta, pois usando o NMAP ou outro programa, poderemos detectar que serviço está rodando e até mesmo rodar programas que tentam se autenticar por meio de força bruta, então, colocamos uma regra para permitir apenas 1 conexão por segundo, caso a segunda seja realizada no intervalo de um segundo, então a mesma será bloqueada.

# iptables -A INPUT -p tcp --dport 2100 -m limit --limit 1/s --limit-burst 1 -j ACCEPT
# iptables -A INPUT -p tcp --dport 2100 -j DROP

- Testando:

* Máquina rodando NMAP e escaneando o IP que roda o SSH na porta 2100.

# nmap -sV -p 2100 192.168.20.10

Starting Nmap 5.00 ( http://nmap.org ) at 2012-02-20 16:26 BRT
Interesting ports on 192.168.20.10:
PORT STATE SERVICE VERSION
2100/tcp open ssh OpenSSH 5.5p1 Debian 6+squeeze1 (protocol 2.0)
MAC Address: 70:71:BC:59:E3:4A (Unknown)
Service Info: OS: Linux

Service detection performed. Please report any incorrect results at http://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 7.34 seconds

# iptables -nvL

* Máquina com as regras e o serviço SSH.

Chain INPUT (policy ACCEPT 6 packets, 1254 bytes)
pkts bytes target prot opt in out source destination
6 312 ACCEPT tcp -- * * 0.0.0.0/0 0.0.0.0/0 tcp dpt:2100 limit: avg 1/sec burst 1
11 592 DROP tcp -- * * 0.0.0.0/0 0.0.0.0/0 tcp dpt:2100

Veja que mesmo bloqueando pacotes que entram com uma frequência de dois por segundo, ainda foram aceitos 6 pacotes, e bloqueado 11 e ainda foi identificado qual serviço roda na porta escaneada.

Seria mais interessante para a segurança, aceitar apenas um ou dois pacotes por minutos ao invés que por segundo, como foi feito nas regras abaixo, aceitando apenas um pacote no intervalo de um minuto.

# iptables -A INPUT -p tcp --dport 2100 -m limit --limit 1/m --limit-burst 1 -j ACCEPT
# iptables -A INPUT -p tcp --dport 2100 -j DROP

- Testando:

* Máquina com NMAP.

# nmap -sV -p 2100 192.168.20.10

Starting Nmap 5.00 ( http://nmap.org ) at 2012-02-20 16:30 BRT
Interesting ports on 192.168.20.10:
PORT STATE SERVICE VERSION
2100/tcp open unknown
MAC Address: 70:71:BC:59:E3:4A (Unknown)

Service detection performed. Please report any incorrect results at http://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 35.46 seconds

# iptables -nvL

Chain INPUT (policy ACCEPT 16 packets, 2732 bytes)
pkts bytes target prot opt in out source destination
1 44 ACCEPT tcp -- * * 0.0.0.0/0 0.0.0.0/0 tcp dpt:2100 limit: avg 1/min burst 1
11 560 DROP tcp -- * * 0.0.0.0/0 0.0.0.0/0 tcp dpt:2100

Agora veja que foi bloqueado 11 pacotes, e só foi aceito um e que o NMAP não conseguiu identificar qual serviço roda na porta aberta, apesar que o mesmo passou quase 36 segundos escaneando mais tempo que da primeira vez, o que não é tanto tempo, porém, já foi obtido mais êxito que da primeira.

Porém, se for aplicar esta regra em um ambiente de produção, tome CUIDADO, pois a conexão, desde a autenticação até a troca de dados, depois que a conexão estiver estabelecida, ficará bem lenta. Mas poderá contornar isto, aplicando uma regra antes desta, aceitando o tráfego de conexões já estabelecidas.

Uma regra que substituiria a última, seria as que estão abaixo, pois assim, ele apenas bloquearia a tentativa de novas conexões, isto irá fazer com que seja estabelecida uma conexão por minuto, assim teria uma boa proteção contra ataques de força bruta.

Por exemplo:

# iptables -A INPUT -p tcp --dport 2100 --syn -m limit --limit 1/m --limit-burst 1 -j ACCEPT
# iptables -A INPUT -p tcp --dport 2100 --syn -j DROP