Firewall Shell script

Firewall Shell Script (parte 5)

     Uso do Firewall Iptables, junto com um proxy de rede (Squid)

#Regras para liberar acesso ao proxy da rede

$IPT -A INPUT -s $REDE -p tcp --sport 1024:65535 --dport 3128 \
-j $AP
$IPT -A INPUT -p tcp --sport 1024:65535 --dport 3128 -m limit \
--limit 1/s --limit-burst 1 -j LOG --log-prefix "FW_PROXY_log:"
$IPT -A INPUT -p tcp --dport 3128 -j $DP



#Força todos os usuários da rede a passarem pelo proxy

$IPT -t nat -I PREROUTING -i $LAN -s $REDE -p tcp --dport 80 \
-m state --state NEW -j REDIRECT --to-port 3128


#Para forçar apenas um range de Ips a passarem pelo proxy

$IPT -t nat -I PREROUTING -i $LAN -p tcp -m iprange --src-range \
192.168.1.50-192.168.1.126  --dport 80 -m state --state NEW \
-j REDIRECT --to-port 3128


 #Para redes, que apenas alguns usuários precisam passar pelo proxy, criam-se várias regras de iptables, para cada ip, ou pode-se usar este script

#Force proxy
proxy=/root/proxy
for i in `cat $proxy`; do
ip=`echo $i | cut -d ';' -f 1`
#
$IPT -t nat -I PREROUTING -i $LAN -p tcp -s $ip --dport 80 \ 
-m state --state NEW -j REDIRECT --to-port 3128
#
echo "IP - force proxy - $ip"
done #Fim do FOR
#

     Crie um arquivo proxy no mesmo diretório e insira os ips, que devem passar pelo proxy

#cd /root
#touch proxy

#echo "192.168.1.25" > proxy
#echo "192.168.1.36" >> proxy
#echo "192.168.1.57" >> proxy

Firewall Shell script

Firewall Shell script (parte 4)

#Chain FORWARD

     A Cadeia FORWARD, é onde ocorre o tráfego "bypass" de pacotes, dentro de um Firewall Iptables. Essa passagem de pacotes, ocorre de forma simétrica, é obrigatório as regras na ida e na volta, passando pelo Firewall.

     Exemplo prático:

#Redirecionamento de acesso remoto via RDP

$IPT -A $FW -i $WAM -o $LAN -s 0/0 -p tcp --sport 1024:65535 --dport 3389 -j ACCEPT

$IPT -A $FW -i $LAN -o $WAN -d 0/0 -p tcp --sport 3389 --dport 1024:65535 -j ACCEPT

$IPT -I $FW -i $WAN -o $LAN -s 0/0 -p tcp --dport 3389 -m limit --limit 1/s --limit-burst 1 -j LOG --log-prefix "FW_RDP_log:"


#Liberar o acesso RDP na cadeia PREROUTING

$IPT -t nat -A PREROUTING -i $WAN -p tcp --dport 3389 -j DNAT --to-destination 192.168.1.100:3389


#Liberar o acesso RDP na cadeia POSTROUTING

$IPT -t nat -A POSTROUTING -d 192.168.1.100 -j SNAT --to 192.168.1.1


#Liberar acesso ao Torrent, via porta 50123, na estação 192.168.1.10, pela FORWARD

$IPT -A $FW -i $WAN -o $LAN -s 0/0 -d 192.168.1.10 -p tcp --sport 1024:65535 --dport 50123 -j ACCEPT

$IPT -A $FW -i $LAN -o $WAN -s 192.168.1.10 -d 0/0 -p tcp --sport 50123 --dport 1024:65535 -j ACCEPT


#Liberar acesso a https, para a rede, pela FORWARD

$IPT -A $FW -i $LAN -o $WAN -s $REDE -d 0/0 -p tcp --sport 1024:65535 --dport 443 -m state --state NEW,ESTABLISHED -j ACCEPT

$IPT -A $FW -i $WAN -o $LAN -s 0/0 -d $REDE -p tcp --sport 443 --dport 1024:65535 -m state --state ESTABLISHED -j ACCEPT

Firewall Shell script

Firewall Shell script (parte 3)

#Importante agora, para sabermos quais regras insserir no Firewall, quem vai nos dizer, é o LOG do Iptables.

$IPT -A C_ARP -m limit --limit 1/s –limit-burst 1 -j LOG --log-prefix "FW_ARP_log:"

$IPT -A INPUT -m limit --limit 1/m -j LOG --log-prefix "FW_INPUT_log:"

$IPT -A $FW -m limit --limit 1/m -j LOG --log-prefix "FW_FORWARD_log:"

Para visualizar os logs:

#tail -n 50 -f /var/log/messages

ou

#tail -n 50 -f /var/log/syslog

  Observe os logs, que ele dirá qual regras são necessárias para sua rede específica.

   Pode-se refinar a busca, usando filtros:

#tail -n 600 /var/log/messages | grep "FW_ARP_log:"

#tail -n 600 /var/log/messages | grep "FW_INPUT_log:"

#tail -n 600 /var/log/messages | grep "FW_FORWARD_log:"

  Provavelmente aparecerão muitas mensagens, que podem ser traduzidas em algumas regras:

$IPT -A INPUT -i $LAN -p udp -m udp -s 0/0 -d 255.255.255.255 --sport 67:68 --dport 67:68 -m limit --limit 2/s --limit-burst 3 -j $AP
$IPT -A INPUT -i $LAN -p udp -m udp --sport 137:139 --dport 137:139 -m limit --limit 3/s --limit-burst 3 -j $AP
$IPT -A INPUT -i $LAN -s $REDE -d 224.0.0.0/24 -m limit --limit 3/s --limit-burst 3 -j $AP

$IPT -A INPUT -i $LAN -s $REDE -d 192.168.1.127 -m limit --limit 3/s --limit-burst 3 -j $AP

#A primeira linha, a regra permite a busca do DHCP, que usa esse endereço e portas 67,68 udp para esse serviço, o limit, limita as conexões.

#A segunda regra é usada para o NetBios da Microsoft

#A terceira regra permite o tráfego à endereços Multcast da rede.

#A quarta regra permite o tráfego à endereço Broadcast da rede.

  Os Logs do Iptables são muito importantes, no quesito de segurança e para identificarmos quais serviços (portas) e endereços, estão sendo requisitados por usuários da rede.

#Uma regrinha básica, para proteger o anonimato de saída de pacotes da rede.

$IPT -t nat -A POSTROUTING -o $WAN -s $REDE -j MASQUERADE

#Uma opção para mascarar a saída de pacotes da rede, porém escolhendo um range específico de portas

$IPT -t nat -A POSTROUTING -o $WAN -p tcp -m tcp -j MASQUERADE --to-ports 1024-6000 -s $REDE

Firewall Shell script

Firewall Shell script (parte 2)

  Continuando com o script de Firewall Iptables netfilter, temos:

#!/bin/sh

#Firewall Netfilter desenvolvido por HenriqueKbs

echo "Inicializando o Firewall de Rede em `uname -n`"

#Utilizaremos caminhos de abreviação, para poupar digitação

IPT="/sbin/iptables"

#Temos que apagar as regras antigas, senão ficarão duplicadas, quando reiniciar

$IPT --flush

$IPT --delete-chain

$IPT -t nat -F

$IPT -t mangle -F

#Política das cadeias na tabela FILTER (primeiramente deixarei em ACCEPT, depois se não ouver nehuma restrição, aos usuários da rede, pode-se mudar para DROP)

#$IPT -P INPUT ACCEPT

#$IPT -P FORWARD ACCEPT

#$IPT -P OUTPUT ACCEPT

#Habilitar módulos do netfilter (necessário dependendo da distro, versão do Kernel e o que for usar)

modprobe ipt_mac

modprobe ipt_ttl

modprobe iptable_nat

modprobe iptable_mangle

modprobe ipt_limit

modprobe ipt_state

modprobe ipt_tos

#Path, álias para alguns componentes do Firewall (faça conforme suas necessidades)

AP="ACCEPT"

DP="DROP"

RJ="REJECT"

FW="FORWARD"

SERVER="192.168.1.10/32"

REDE="192.168.1.0/25"

DNS1="8.8.8.8"

DNS2="8.8.4.4"

HOST1="192.168.1.126/32"

WAN="eth0"

LAN="eth1"

#Para liberar o trafego de pacotes bypass na FORWARD

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

#Criar uma cadeia nova

$IPT -N C_ARP

#Foi criada uma nova cadeia, para trabalhar com pacotes oriundos de um roteador local, usando como base o endereço físico mac address.

$IPT -I INPUT -i $WAN -m mac --mac-source 00:02:22:1B:AE:AF -j C_ARP

$IPT -I $FW -i $WAN -m mac --mac-source 00:02:22:1B:AE:AF -p tcp -j C_ARP

$IPT -A C_ARP -m state --state INVALID -j $DP

#Regras para loopback

$IPT -A INPUT -i lo -s 127.0.0.1 -j $AP

$IPT -A OUTPUT -o lo -d 127.0.0.1 -j $AP

$IPT -t nat -A OUTPUT -o lo -d 127.0.0.1 -j $AP

#Regras básicas na cadeia C_ARP

$IPT -A C_ARP -p udp --sport 53 -s $DNS1 -j $AP

$IPT -A C_ARP -p udp --sport 53 -s $DNS2 -j $AP

$IPT -A C_ARP -s 0/0 -p tcp --sport 80 -j $AP

$IPT -A C_ARP -s 0/0 -p tcp --sport 443 -j $AP

$IPT -A C_ARP -s 0/0 -p udp --sport 123 -j $AP

$IPT -A C_ARP -p icmp -m icmp ! --icmp-type 8 -m limit --limit 2/s -j $AP

$IPT -A C_ARP -s 0/0 -p tcp --sport 809 -j $AP

$IPT -A C_ARP -s 0/0 -p tcp --sport 995 -j $AP

$IPT -A C_ARP -d 0/0 -p tcp --dport 587 -j $AP

#Liberar acesso via SSH para o HOST1

$IPT -A INPUT -s $HOST1 -d $SERVER -p tcp --sport 1024:65535 --dport 22 -j $AP

$IPT -A INPUT -p tcp --dport 22 -j $DP

#Liberar acesso na saída do Firewall

$IPT -A OUTPUT -p icmp -m icmp ! --icmp-type 0 -m limit --limit 2/s -j $AP

$IPT -A OUTPUT -m state --state NEW,ESTABLISHED -j $AP

#Algumas regras de Bloqueio

$IPT -t mangle -A PREROUTING -i $WAN -s 0/0 --dport 23 -j $DP

$IPT -t mangle -A PREROUTING -i $LAN -m iprange --src-range 192.168.1.1-192.168.1.49 -d 0/0 -p tcp --sport 1024:65535 --dport 80:443 -m string --algo bm --string "facebook" -j $DP

#Bloqueio de Traceroute

$IPT -A C_ARP -p udp -m udp -s 0/0 --dport 33435:33525 -j $DP

Firewall Shell Script

Firewall Shell Script (parte 1)

   Passo a passo, como desenvolver um Firewall personalizado, completo, portável para várias distros Linux.

   A forma mais fácil para começar a desenvolver um Firewall baseado no Iptables, em qualquer distro Linux, é começar a mexer com o arquivo dump do Iptables, com os seguintes comandos:

#iptables-save > Firewall

#iptables-restore < Firewall

   Mas o arquivo dump, salvo com o comando iptables-save, é um arquivo bastante analítico, ruim de ser editado e pouco portável.

   Por isso o ideal é desenvolver um Firewall em Shell Script. Primeiro temos que entender o que é um interpretador Shell. Num sistema operacional Linux, primeiramente temos o Hardware (dispositivos físicos), a camada que envolve o Hardware, é o Kernel, responsável pelo gerenciamento e controle do Hardware. O Kernel está envolto por programas ou comandos que realizam tarefas específicas, a quarta camada, responsável pela interação do usuário com o sistema operacional, é o Shell, que usaremos para desenvolver o script de Firewall Iptables Netfilter.

Versões do Shell

Bourne Shell – é o padrão do UNIX foi escrita por Stephen Bourne da Bell Labs. Este é o Shell mais utilizado no mundo UNIX, será utilizado em todos os scripts de Firewall Iptables que desenvolvo. Sua extensão é .sh

Bourne-Again Shell - É quase 100% compatível com o Bourne Shell, porém trazem contigo inúmeros comandos derivados do C Shell e implementações feitas para o Korn Shell. Sua extensão é .bash

Korn Shell – Foi desenvolvido por David Korn da Bell Labs da AT&T, é um desenvolvimento do Bourne Shell, sendo assim compatível com o .sh. Sua extensão é .ksh

C Shell – Foi desenvolvido por Bill Joy da Berkeley University, sua estrutura de linguagem é bastante parecida com a linguagem C. Sua extensão é .csh

   Entendendo o que é o Shell, vamos começar a desenvolver um script de Firewall Iptables.

Primeiro passo (como administrador):

#cd /root

#touch Firewall

#chmod +x Firewall

#nano Firewall

   Na primeira linha do Firewall, sempre colocaremos #. A tralha somente é inserida na primeira linha ou comentários sobre alguma coisa, dentro do script. Então a primeira linha do Firewall ou qualquer script, ficaria assim:

#!/bin/sh

  Essa primeira linha, indica o caminho do interpretador Shell, no caso será usado o Bourne Shell.

 

 

crontab

crontab

É um agendador de tarefas nativo no Linux.

Para usá-lo, basta dar o comando:

#crontab -e

Sintaxe do crontab:

M    H    D    M    S      programa

I      O     I     Ê    E

N     R   A     S    M

U     A                A

T     S                 N

O                       A

S

0-59/10 * * * * /root/resolv.sh

0 0-23/1 * * * /usr/sbin/ntpdate -u 200.20.186.75

0 0 * * 0 reboot

     A primeira linha indica que o programa resolv.sh vai rodar a cada dez minutos.

     A segunda linha indica que horário do sistema será atualizado de hora em hora.

     A terceira linha indica que o computador será reiniciado todo domingo às 00:00 horas.

#cat resolv.sh

#!/bin/sh

echo "nameserver 127.0.0.1" > /etc/resolv.conf

echo "nameserver 8.8.8.8 >> /etc/resolv.conf

echo "nameserver 189.38.95.95 >> /etc/resolv.conf

Gravar um DVD via linha de comando no Linux

 Para gravar um DVD, via linha de comando no Linux:

 Instale o pacote growisofs (Debian e derivados)

#apt-get update

#apt-get install growisofs



 Gravar um arquivo ou pasta

#growisofs -Z /dev/sr0 -r -J /caminho/do/arquivo ou pasta

 Exemplo:

#growisofs -Z /dev/sr0 -r -J /home/joao/Downloads



 Criar um arquivo de Imagem .iso

#genisoimage -r -J -o arquivo.iso /caminho/do/arquivo


 Para gravar a Imagem num DVD

#growisofs -dvd-compat -Z /dev/sr0=/caminho/da/imagem.iso



 Para apagar um DVD-RW (regravável)

#dvd+rw-format -blank /dev/sr0