Primeiramente precisamos saber quais os serviços (portas) estão rodando em nosso servidor, para que possamos saber o que queremos proteger. Você pode usar o comando nmpa para fazer scanner de portas, instale ele com apt, e utilize ex: nmap localhost.

No meu exemplo vamos suporte que nosso servidor esteja com SSH e o APACHE instalado, logo temos a porta 22, e a porta 80. Agora preciso saber quem irá ter acesso a este servidor, quais IPs qual eu chamo normalmente de “IPs de gerencia”

Agora que sei que vou fechar as portas 22 e 80 e que meus IPs de gerencia são 192.168.254.0/24, 250.250.250.0/28 vamos as alterações do nosso script:

Defina as portas que deseja proteger separada por “;”

PORTAS="22;80"

Defina os IPv4s que terão acesso separado por “;”
É válido lembrar do IP de localhost 127.0.0.1, caso contrário alguma aplicações local não ira funcionar ex.: mysql seria uma.

IP4GERENCIA="127.0.0.1;192.168.254.0/24;250.250.250.0/28"

Defina os IPv4s que terão acesso. (localhost ::1)

IP6GERENCIA="::1;2001:db8:bebe:c0ca::/64"

Crie o arquivo do nosso script /etc/init.d/rr-firewall, irei utilizar o editor vim, mas você pode usar o seu favorito.

# vim /etc/init.d/rr-firewall

#!/bin/bash
### BEGIN INIT INFO
# Provides:          rr-firewall
# Required-Start:    $all
# Required-Stop:
# Default-Start:     2 3 4 5
# Default-Stop:
### END INIT INFO

#Defina as portas que deseja proteger
PORTAS="22;80"
#Defina os IPv4s que terão acesso a estas portas
IP4GERENCIA="127.0.0.1;192.168.254.0/24;250.250.250.0/28"
#Defina os IPv4s que terão acesso a estas portas
IP6GERENCIA="::1;2001:db8:bebe:c0ca::/64"

# Não altere as linhas abaixo
VERMELHO='\033[1;31m'
VERDE='\033[1;32m'
AZUL='\033[1;36m'
AMARELO='\033[1;33m'
ROSA='\033[1;35m'
NC='\033[0m'

function startFirewall(){
    /sbin/iptables -F
    /sbin/iptables -X
    /sbin/iptables -t nat -F
    /sbin/iptables -X -t nat
    /sbin/iptables -F -t mangle
    /sbin/iptables -X -t mangle
    /sbin/ip6tables -F
    /sbin/ip6tables -X
    /sbin/ip6tables -F -t mangle
    /sbin/ip6tables -X -t mangle
    /sbin/modprobe ip_conntrack_ftp
    /sbin/modprobe ip_nat_ftp
    /sbin/modprobe ipt_state
    /sbin/modprobe ipt_limit
    /sbin/modprobe ipt_MASQUERADE
    /sbin/modprobe ipt_LOG
    /sbin/modprobe iptable_nat
    /sbin/modprobe iptable_filter
    /sbin/modprobe ip_gre
    #Protege portas IPv4
    echo; echo -e "[${ROSA} Regras IPv4 ${NC}]"; echo
    portas=$(echo $PORTAS | tr ";" "\n")
    for porta in $portas
    do
        ip4s=$(echo $IP4GERENCIA | tr ";" "\n")
        for ip4 in $ip4s
        do
            /sbin/iptables -A INPUT -s $ip4 -p tcp --dport $porta -j ACCEPT
            /sbin/iptables -A INPUT -s $ip4 -p udp --dport $porta -j ACCEPT
            echo -e "[${VERDE} ok ${NC}] Porta ${AMARELO}[$porta]${NC} aberta para ${AZUL}$ip4${NC}"
            sleep 0.1
        done
    done
    portas=$(echo $PORTAS | tr ";" "\n")
    for porta in $portas
    do
        /sbin/iptables -A INPUT -p tcp --dport $porta -j DROP
        echo -e "[${VERDE} ok ${NC}] Porta ${VERMELHO}[$porta]${NC} fechada"
        sleep 0.1
    done
    #Protege portas IPv6
    echo; echo -e "[${ROSA} Regras IPv6 ${NC}]"; echo

    portas=$(echo $PORTAS | tr ";" "\n")
    for porta in $portas
    do
        ip6s=$(echo $IP6GERENCIA | tr ";" "\n")
        for ip6 in $ip6s
        do
            /sbin/ip6tables -A INPUT -s $ip6 -p tcp --dport $porta -j ACCEPT
            /sbin/ip6tables -A INPUT -s $ip6 -p udp --dport $porta -j ACCEPT
            echo -e "[${VERDE} ok ${NC}] Porta ${AMARELO}[$porta]${NC} aberta para ${AZUL}$ip6${NC}"
        done
    done
    portas=$(echo $PORTAS | tr ";" "\n")
    for porta in $portas
    do
        /sbin/ip6tables -A INPUT -p tcp --dport $porta -j DROP
        echo -e "[${VERDE} ok ${NC}] Porta ${VERMELHO}[$porta]${NC} fechada"
        sleep 0.1
    done
}

function stopFirewall(){
    /sbin/iptables -F
    /sbin/iptables -X
    /sbin/iptables -t nat -F
    /sbin/iptables -X -t nat
    /sbin/iptables -F -t mangle
    /sbin/iptables -X -t mangle

    /sbin/ip6tables -F
    /sbin/ip6tables -X
    /sbin/ip6tables -F -t mangle
    /sbin/ip6tables -X -t mangle

    /sbin/modprobe ip_conntrack_ftp
    /sbin/modprobe ip_nat_ftp
    /sbin/modprobe ipt_state
    /sbin/modprobe ipt_limit
    /sbin/modprobe ipt_MASQUERADE
    /sbin/modprobe ipt_LOG
    /sbin/modprobe iptable_nat
    /sbin/modprobe iptable_filter
    /sbin/modprobe ip_gre
}

case "$1" in
    start )
        startFirewall
        echo; echo -e "[${VERDE} Firewall carregado ${NC}]"; 
        echo "Use: /etc/init.d/rr-firewall status"
        echo "para verificar as regras"
        ;;

    stop )
        stopFirewall
        echo; echo -e "[${VERDE} Regras de firewall removidas ${NC}]"; echo
        ;;

    restart )
        stopFirewall
        sleep 1
        startFirewall
        ;;

    status )
        echo; echo -e "[${VERDE} Regras IPv4 ${NC}]"; echo
        /sbin/iptables -nL
        echo; echo -e "[${VERDE} Regras IPv6 ${NC}]"; echo
        /sbin/ip6tables -nL
        ;;

    * )
        echo "Opção inválida, use rr-firewall start | stop | restart | status"
        ;;
esac

Por fim aplicamos as permissões necessárias.

# chmod a+x  /etc/init.d/rr-firewall

Para executa-lo use:
/etc/init.d/rr-firewall start

/etc/init.d/rr-firewall status

/etc/init.d/rr-firewall stop

/etc/init.d/rr-firewall restart

Nos prints estou fechando a porta 3306 e 80

Pronto! Seu servidor já vai estar protegido

Como carregar ele na inicialização? Acesse: Como usar o systemd para iniciar seu script/Aplicação no Debian

Dúvidas sugestões deixe seu comentário.

O post Modelo simples e funcional de Firewall com iptables apareceu primeiro em Remontti.

Primeiramente instalamos o pacote iproute 2
# aptitude update
# aptitude install iproute

Após configure as tabelas:

# vim /etc/iproute2/rt_tables
Adicione essas duas linhas no final do arquivo:

200 uplink1
201 uplink2

Vamos configurar nossa interface onde em eth0 192.168.1.1 / eth1 192.168.2.1 são os gateways
# vim /etc/network/interfaces

# LOCALHOST
auto lo
iface lo inet loopback

# LINK 1

auto eth0
iface eth0 inet static
        address 192.168.1.100
        netmask 255.255.255.0

        post-up ip route add 192.168.1.1/32 dev eth1 src 192.168.1.100 table uplink1
        post-up ip route add default via 192.168.1.1 table uplink1
        post-up ip rule add from 192.168.1.100 table uplink1
        post-down ip rule del from 192.168.1.100 table uplink1

# LINK 2

auto eth1
iface eth1 inet static
        address 192.168.2.100
        netmask 255.255.255.0

        post-up ip route add 192.168.2.1/32 dev eth1 src 192.168.2.210 table uplink2
        post-up ip route add default via 192.168.2.1 table uplink2
        post-up ip rule add from 192.168.2.210 table uplink2
        post-down ip rule del from 192.168.2.210 table uplink2

# REDE CLIENTE
auto eth2
iface eth2 inet static
        address 192.168.3.1
        netmask 255.255.255.0

Reinicie o serviço:
# /etc/init.d/networking restart

Agora vamos criar um firewall, criaremos as rotas.

#! /bin/sh

# Ativa forward
echo "1" > /proc/sys/net/ipv4/ip_forward

# Limpa regras
/sbin/iptables -F
/sbin/iptables -X
/sbin/iptables -t nat -F
/sbin/iptables -X -t nat
/sbin/iptables -F -t mangle
/sbin/iptables -X -t mangle

# Carrega modulos
/sbin/modprobe iptable_nat
/sbin/modprobe ip_conntrack_ftp
/sbin/modprobe ip_nat_ftp
/sbin/modprobe ipt_LOG
/sbin/modprobe ipt_REJECT
/sbin/modprobe ipt_MASQUERADE

#Libera navegacao nas interfaces
/sbin/iptables -t nat -A POSTROUTING -s 192.168.30/24 -o eth0 -j MASQUERADE
/sbin/iptables -t nat -A POSTROUTING -s 192.168.30/24 -o eth1 -j MASQUERADE

# Configurações Proxy
# /sbin/iptables -t nat -A PREROUTING -i eth2 -p tcp --dport 80 -j REDIRECT --to-port 3128
# /sbin/iptables -A PREROUTING -t mangle -s 192.168.3.0/24 -d 0/0 -j MARK --set-mark 3
# /sbin/iptables -t mangle -A OUTPUT -p TCP -d ! 192.168.3.0/24 --dport 80 -m owner --uid-owner 23 -j MARK --set-mark 3

# Faz com que o servico dns faca consultas pelo outro link
/sbin/iptables -t mangle -A OUTPUT -p UDP --dport 53 -m owner --uid-owner 25 -j MARK --set-mark 2

# Deleta rotas
route del default

# Load balance
ip route add default scope global nexthop via 192.168.1.1 dev eth0 weight 1 nexthop via 192.168.2.1 dev eth1 weight 1

# Limpa cache
ip route flush cached

Use o comando “ip route show table main” para ver como ficou…
# ip route show table main

192.168.1.1/24 dev eth0 proto kernel scope link src 192.168.1.100
192.168.2.1/24 dev eth1 proto kernel scope link src 192.168.2.100
192.168.3.1/24 dev eth2 proto kernel scope link src 192.168.3.1
default
nexthop via 192.168.1.100 dev eth0 weight 1
nexthop via 192.168.2.100 dev eth1 weight 1

Adicione no cron o comando para limpar o cache dos dns a cada 10 min
# vim /etc/crontab
00-59/10 * * * * root ip route flush cached

Aqui fiz o siguinte script para verificar se algum dos link cai, assim refazendo a rota e deixadondo para o que estiver online.

# vim /root/uplink.sh

#! /bin/sh
# - - - - - - - - - - - - - - - #
# Script por Rudimar Remontti   #
# www.remontti.com.br           #
# - - - - - - - - - - - - - - - #
echo -e '\e[33;1mVerificando Links: \e[m'

# - - - - - - - - - - - #
# Configuracoes         #
# - - - - - - - - - - - #
GTW_1=192.168.1.1
ITF_1=eth0
GTW_2=192.168.2.1
ITF_2=eth1
RT_BRT_1=200.176.3.142 # Ip do terra.com.br ele ira pingar p/ verificar se responde
RT_BRT_2=200.176.3.142 # Ip do terra.com.br...
# - - - - - - - - - - - #

echo
echo -e "\e[30;1mLink 1: $GTW_1\e[m"
echo -e "\e[30;1mLink 2: $GTW_2\e[m"
echo 

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
PING_1=`ping $RT_BRT_1 -I $ITF_1 -c 1 |grep packets |cut -c 24`
PING_2=`ping $RT_BRT_2 -I $ITF_2 -c 1 |grep packets |cut -c 24`
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #

UP=`echo "($PING_1 + $PING_2)" | bc`
if [ $UP = 2 ]; then 

        route del default
        ip route add default scope global nexthop via $GTW_1 dev $ITF_1 weight 1 nexthop via $GTW_2 dev $ITF_2 weight 1
        ip route flush cached

        echo -n 'Link 1 e Link 2  Status:     '
        echo -e '\e[32;1m[ ON ] \e[m'
        echo

elif [ $UP = 0 ]; then

        route del default
        ip route add default scope global nexthop via $GTW_1 dev $ITF_1 weight 1 nexthop via $GTW_2 dev $ITF_2 weight 1
        ip route flush cached

        echo
        echo -n Link 1:
        echo -e '\e[32;1m  [  OKAY  ] \e[m'
        echo -n Link 2:
        echo -e '\e[32;1m  [  OKAY  ] \e[m'
        echo

elif [ $UP = 1 ]; then
        echo
        if [ $PING_1 = 1 ]; then
                echo -n Link 1:
                echo -e '\e[32;1m  [  OKAY  ] \e[m'
        else
                route del default
                ip route add default scope global nexthop via $GTW_2 dev $ITF_2 weight 1
                ip route flush cached
                data=`date`
                echo "$data -> Link 1 OFF" >> /root/links.log
                echo -n Link 1:
                echo -e '\e[31;1m  [  OFF   ] \e[m'
        fi
        if [ $PING_2 = 1 ]; then
                echo -n Link 2:
                echo -e '\e[32;1m  [  OKAY  ] \e[m'
        else
                route del default
                ip route add default scope global nexthop via $GTW_1 dev $ITF_1 weight 1
                ip route flush cached
                data=`date`
                echo "$data -> Link 2 OFF" >> /root/links.log
                echo -n Link 2:
                echo -e '\e[31;1m  [  OFF   ] \e[m'

        fi
        echo
        if [ $PING_1 = 0 ]; then
                echo -e '\e[30;1mRotas reconfigurada, gatway através do Link 2.\e[m'
                ROTE=`ip route show |grep default |cut -c 9-100`
                echo -e "\e[30;1m$ROTE\e[m"

        elif [ $PING_2 = 0 ]; then
                echo -e '\e[30;1mRotas reconfigurada, gatway através do Link 1.\e[m'
                ROTE=`ip route show |grep default |cut -c 9-100`
                echo -e "\e[30;1m$ROTE\e[m"
        fi
else
        echo ERRO!
fi
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - #
echo
ip route show |grep nexthop
echo

# chmod 755 /root/uplink.sh

Adicionamos ao cron (5min)
# vim /etc/crontab
00-59/5 * * * * root /root/uplink.sh

Carregue seu firewall na inicialização do sistema, utilize o iptraf para ver o trafego saindo pelas duas interfaces.
Se vc tem dois link com cargas diferente altere o weight.

Abraço

O post Balanceamento de Carga apareceu primeiro em Remontti.