Continuação da saga Linuxer

Em 2001, em sociedade com Juliano Cardoso, um colega de trabalho, fundei a Maxlinux em Ilhéus. Era uma empresa de assistência técnica, revenda de suprimentos de informática e provedor de acesso (apenas dedicado à cabo). O roteador só precisava de dois endereços IP e uma rota default. Com um script* era possível controlar o acesso dos clientes.

Em 2003 surgiu a concorrência do Velox, e com isso a necessidade de expansão geográfica. Até então os enlaces wifi ponto a ponto eram feitos com placas PCMCIA Orinoco 2.4 em computadores Pentium 100 com Linux. Com isso conseguíamos atingir bairros periféricos onde o Velox não chegava. Depois vieram as CPEs Linksys (WET11 e WAP11) com as antenas offset Zirok (difíceis de alinhar). Por conta da própria limitação da tecnologia tínhamos muitos problemas com a qualidade desses links. Só com o advento dos equipamentos em 5.8 passamos a confiar nos enlaces sem fio. Os mais comuns eram cartões mini-PCI de 5.8 em placas Mikrotik RouterBoard. Até surgir o Ubiquiti, principalmente a linha AirMax, com a tecnologia MIMO. Nesse estágio o provedor passou a fornecer um serviço confiável através de rádio.

Inicialmente as redes eram uma única rede, com todos os rádios funcionado no modo bridge. Posteriormente, com a popularização do método de autenticação PPPoE, usando-se concentradores nas pontas (nos bairros), pudemos setorizar a rede usando roteamento, primeiro estático e depois automático através de OSPF, diminuindo assim problemas, como excesso de broadcast e limitando outros, como loop, por exemplo.

O grande facilitador para uma melhor gestão da rede foi o Mikrotik RouteOS, com a sua GUI Winbox. Confesso que no início tinha um pé atrás com ele. Achava que tudo que se fazia com o Mikrotik era possível fazer diretamente no Linux e com mais flexibilidade. Isso até podia ser verdade, mas com as vantagens de menor custo, simplicidade para configurar e redução de problemas por não usar computadores (com peças móveis, HDs, etc), acabei me rendendo. Ainda que ele não seja livre, por baixo do capô do RouterOS está o Linux.

Aguardem os próximos capítulos…

* Abaixo um exemplo de um script simples usado em 2001.

#!/bin/bash
dir_cbq="/etc/sysconfig/cbq/"
rm -f /etc/sysconfig/cbq/cbq*
iptables -t nat -F POSTROUTING
echo -e 127.0.0.1'\t'localhost > /etc/hosts
count="2"
for ip in `cat /etc/rc.d/dedicados|cut -d# -f 1` ; do
cliente="`grep -w $ip /etc/rc.d/dedicados|cut -d# -f2`"
velocidade="`grep -w $ip /etc/rc.d/dedicados|cut -d# -f3`"
if [ `echo $ip|cut -d. -f3` = 0 ] ; then interface="eth1" ;
elif [ `echo $ip|cut -d. -f3` = 100 ] ; then interface="eth3" ;
elif [ `echo $ip` = 192.0.144.138 ] ; then interface="eth3" ;
elif [ `echo $ip` = 192.0.144.142 ] ; then interface="eth1" ;
else interface="eth2"; fi
if [ `echo $ip|cut -d. -f1` != 200 ] ; then
echo Levantando o cliente: $cliente com o IP: $ip;
iptables -A POSTROUTING -t nat -s $ip -o eth0 -j SNAT --to 192.0.144.130 ;
fi
echo -e $ip'\t'$cliente >> /etc/hosts
if [ -n "$velocidade" ] ; then
if [ `echo $count|wc -c` = 2 ] ; then
arq_cbq="cbq-000$count.$cliente";
elif [ `echo $count|wc -c` = 3 ] ; then
arq_cbq="cbq-00$count.$cliente";
elif [ `echo $count|wc -c` = 4 ] ; then
arq_cbq="cbq-0$count.$cliente";
elif [ `echo $count|wc -c` = 5 ] ; then
arq_cbq="cbq-$count.$cliente"; fi
echo "DEVICE="$interface",10Mbit,1Mbit" > $dir_cbq$arq_cbq
echo "RATE="$velocidade"Kbit" >> $dir_cbq$arq_cbq
echo "WEIGHT="$[$velocidade/10]"Kbit" >> $dir_cbq$arq_cbq
echo PRIO=5 >> $dir_cbq$arq_cbq
echo RULE=$ip >> $dir_cbq$arq_cbq
echo RULE=$ip, >> $dir_cbq$arq_cbq
echo BOUNDED=yes >> $dir_cbq$arq_cbq
echo ISOLATED=yes >> $dir_cbq$arq_cbq
let count=count+1
fi
done
killall -HUP squid
service cbq stop
service cbq start

E aqui um usado em 2007

#!/bin/bash

# Este script serve para facilitar o controle de acesso de usuarios
# de uma rede a Internet.
# Controla banda, MAC, DHCP, faz redirecionamento de portas
# entre outras coisas.
# 
# Autor:
# Daniel Vianna Hoisel <daniel@maxlinux.com.br>
#
# Copyright (C) 2007 Daniel Vianna Hoisel
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of version 2 of the GNU General Public
# License as published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
# USA
#

# Versao 20070531.0
# Pendente funcao para criar arquivos para dhcpd
# Pendente funcao para verificar hora e baseado nela decidir quanto aos diversos planos
# Verificar o plano, caso seja um diferenciado checar a hora, se a hora bater
# executar as regras diferenciadas
# Rodar este script no cron as 08:00 e as 20:00 (sugestao)
# Verifica se o programa ja esta rodando
if [ -f /var/run/acesso.run ]; then
 echo "O sistema ja esta em uso. Se voce tem certeza de que nao,"
 echo "digite rm -f /var/tmp/acesso.run e rode-o novamente."
 exit 0
fi
# Cria arquivo para identificar que ja esta rodando
> /var/tmp/acesso.run
# Carrega o arquivo de configuracao
. /usr/share/acesso/acesso.conf
# Funcao para ecoar o OK bonitinho
function ok ()
{

echo -e "[ \\033[1;32mok\\033[0;39m ]"

} # ok()

echo "Carregando módulos do Netfilter (se necessário)"
# identifica a release do kernel
KERLNEL_REL=`uname -r`
for MODULO in `cat $MODULOS` ; do
if [ -f /lib/modules/$KERNEL_REL/kernel/net/ipv4/netfilter/$MODULO.ko ]; then
 $MP $MODULO ;
fi
done
ok

# Escreve o nome do host no arquivo /etc/hosts
echo -e 127.0.0.1'\t'localhost > /etc/hosts
echo -e $IP_SAIDA'\t'$HOST >> /etc/hosts

function zera_regras ()
{

$IPT -F
$IPT -F -t nat
$IPT -F -t filter
$IPT -t nat -F POSTROUTING
$IPT -t mangle -F PREROUTING

} # zera_regras()

function regras_iniciais ()
{
# Define politica de forward para descartar
$IPT -t filter -P FORWARD DROP
# Barrando forward entre interfaces
$IPT -A FORWARD -i! $INT_SAIDA -o! $INT_SAIDA -j REJECT
# Escreve regra para liberar limitacao para pop3 ftp imap e https
# Descobre as interfaces internas
INT_INTERNAS="eth1 eth2 eth3 eth4 eth5"
for INT_INTERNA in $INT_INTERNAS; do
echo " class https { bandwidth 100000; limit 100000; burst 0; priority 1; client https { bandwidth 100000; limit 100000; burst 0; priority 1; dst { 0.0.0.0/32; }; src { 0.0.0.0/32 443; }; }; };" > $DIR_HTB/$INT_INTERNA-qos.cfg
echo " class servicos_locais { bandwidth 100000; limit 100000; burst 0; priority 1; client servicos_locais { bandwidth 100000; limit 100000; burst 0; priority 1; dst { 0.0.0.0/32; }; src { $IP_WWW/32 21 80 110 143; }; }; };" >> $DIR_HTB/$INT_INTERNA-qos.cfg
done

} # regras_iniciais()

function servidores_sem_proxy ()
{
# Gera loop para processar arquivo com lista de ips
for SERVIDOR_SEM_PROXY in `cat $SERVIDORES_SEM_PROXY` ; do
IP="`echo $SERVIDOR_SEM_PROXY|cut -d, -f1`";
echo Retirando sites do proxy transparente;
$IPT -t nat -A PREROUTING -p tcp -d $IP --dport 80 -j ACCEPT;
done

} # servidores_sem_proxy()

function usuarios_sem_proxy ()
{
# Gera loop para processar arquivo com lista de ips
for USUARIO_SEM_PROXY in `cat $USUARIOS_SEM_PROXY` ; do
IP="`echo $USUARIO_SEM_PROXY|cut -d, -f1`";
echo Retirando usuarios do proxy transparente;
$IPT -t nat -A PREROUTING -p tcp -s $IP --dport 80 -j ACCEPT;
done

} # usuarios_sem_proxy()

function regras_mac ()
{
# Atribui regra para aceitar encaminhamento com origem sendo o IP do cliente checando o par IP/MAC
#$IPT -t filter -A FORWARD -d 0/0 -s $ip -j ACCEPT
$IPT -t filter -A FORWARD -d 0/0 -s $IP -m mac --mac-source $MAC -j ACCEPT ;
# Atribui regra para aceitar encaminhamento com destino sendo o IP do cliente
$IPT -t filter -A FORWARD -d $IP -s 0/0 -j ACCEPT
# Atribui regra para aceitar pacotes de entrada com origem do IP do cliente checando o par IP/MAC
#$IPT -t filter -A INPUT -s $ip -d 0/0 -j ACCEPT
$IPT -t filter -A INPUT -s $IP -d 0/0 -m mac --mac-source $MAC -j ACCEPT ;
# Atribui regra para aceitar pacotes de saida com origem no IP do cliente
$IPT -t filter -A OUTPUT -s $IP -d 0/0 -j ACCEPT

} # regras_mac

function regras_finais ()
{

# Barrando encaminhamento para a porta 25(SMTP)
$IPT -A FORWARD -p tcp --dport 25 -j REJECT
# Proxy Transparente
$IPT -t nat -A PREROUTING -i! $INT_SAIDA -p tcp --dport 80 -j REDIRECT --to-port 3128
# Atribui regra para aceitar acesso de SSH
$IPT -t filter -A INPUT -p tcp --dport 22 -j ACCEPT
# Atribui regra para negar pacotes de entrada para todos os que nao estiverem cadastrados
$IPT -t filter -A INPUT -i! $INT_SAIDA -j DROP

} # regras_finais()

function redireciona_portas ()
{

# Gera loop para processar arquivo com lista de ips e portas
for REGISTRO in `cat $REDIRECIONAMENTO` ; do
IP="`echo $REGISTRO|cut -d, -f1`"
PORTA="`echo $REGISTRO|cut -d, -f2`"
PORTA_REDIR="`echo $REGISTRO|cut -d, -f3`"
$IPT -A FORWARD -p tcp -i $INT_SAIDA -d $IP --dport $PORTA -j ACCEPT
$IPT -t nat -A PREROUTING -p tcp -i $INT_SAIDA --dport $PORTA_REDIR -j DNAT --to $IP:$PORTA
done

} # redireciona_portas()

function bloqueia_ips ()
# Gera loop para processar arquivo com lista de ips ou classes
for IP_BLOQUEADO in `cat $IPS_BLOQUEADOS` ; do
$IPT -A INPUT -p tcp -s $IP_BLOQUEADO -j REJECT
$IPT -A INPUT -p udp -s $IP_BLOQUEADO -j REJECT
done

} # bloqueia_ips()

function bloqueia_portas ()
{

# Gera loop para processar arquivo com lista de portas
for PORTA in `cat $PORTAS` ; do
#$IPT -A FORWARD -p tcp --dport $porta -j LOG --log-prefix "Enc. de $porta descartado: "
$IPT -A FORWARD -p tcp --dport $PORTA -j REJECT
$IPT -A INPUT -p tcp --dport $PORTA -j REJECT
$IPT -A INPUT -p tcp --sport $PORTA -j REJECT
$IPT -A OUTPUT -p tcp --dport $PORTA -j REJECT
$IPT -A OUTPUT -p tcp --sport $PORTA -j REJECT
done

} # bloqueia_portas()

function libera_smtp ()
{

# Gera loop para processar arquivo com lista de servidores SMTP
for SERVIDOR in `cat $SMTP` ; do
$IPT -A FORWARD -p tcp -s $SERVIDOR --dport 25 -j ACCEPT
$IPT -A FORWARD -p tcp -d $SERVIDOR --dport 25 -j ACCEPT
done

} # libera_smtp()

function le_dados ()
{

# Identifica a situacao
SITUACAO="`echo $USUARIO|cut -d, -f5`"
# Identifica o IP
IP="`echo $USUARIO|cut -d, -f1`"
# Identifica os valores dos octetos referentes a rede
OCT123="`echo $IP|cut -d. -f1,2,3
# Identifica o MAC ADDRESS
MAC="`echo $USUARIO|cut -d, -f2`"
# Identifica o nome do cliente
USER="`echo $USUARIO|cut -d, -f3`"
# Identifica a velocidade do cliente
VELOCIDADE="`echo $USUARIO|cut -d, -f4`"
# Detecta a interface a qual o cliente esta atrelado
INTERFACE="`$IP -o -4 a|grep "\.$OCT123\."|cut -f 2 -d ' '`"
# Detecta a rede a qual o cliente esta atrelado
REDE="`route -n|grep ".\$OCT123\."|cut -f 1 -d ´ ´`"
# Detecta a mascara da rede a qual o cliente esta atrelado
MASCARA="`route -n|grep ".\$OCT123\."|cut -f 3 -d ´ ´`"
# Atribui regra para aceitar encaminhamento com origem sendo o IP do cliente checando o par IP/MAC
#$IPT -t filter -A FORWARD -d 0/0 -s $ip -j ACCEPT
$IPT -t filter -A FORWARD -d 0/0 -s $ip -m mac --mac-source $mac -j ACCEPT ;
# Atribui regra para aceitar encaminhamento com destino sendo o IP do cliente
$IPT -t filter -A FORWARD -d $ip -s 0/0 -j ACCEPT

} # le_dados()

function gera_arquivos_dhcpd ()
{

# Escreve o IP e o nome do cliente no arquivo /etc/hosts
echo -e $ip'\t'$cliente >> /etc/hosts
# Gera arquivos do dhcpd
#Falta fazer
$CAT >> /etc/dhcp/dhcpd.conf << EOF
host $cliente {
 hardware ethernet $mac;
 fixed-address $ip;
 option host-name "$cliente";
}
EOF


} # gera_arquivos_dhcpd()

function gera_arquivos_iptraf ()
{
# Gera arquivo para o IPTRAF
> $ARQ_IPTRAF
MAC_SEM_2_PONTOS=`echo $MAC|tr -d :|tr "[:upper:]" "[:lower:]"`
echo -e $MAC_SEM_2_PONTOS:$USUARIO >> $ARQ_IPTRAF

} # gera_arquivos_iptraf()


function libera_acesso_nat ()
{

# Inicia loop para cada linha do arquivo de clientes
for USUARIO in `cat $USUARIOS_MASCARADOS` ; do
le_dados
if [ $SITUACAO != b ] ; then
# Atribui regra para fazer NAT para o IP do cliente caso não tenha IP válido
$IPT -A POSTROUTING -t nat -s $IP -o $INT_SAIDA -j SNAT --to $IP_SAIDA ;
# Ecoa na tela a mensagem de habilitação do cliente
#echo -e "Habilitando: \\033[1;34m$cliente\\033[0;39m com o IP: \\033[1;33m$ip\\033[0;39m limitado à: \\033[1;37m$velocidade\\033[0;39m Kbps [ \\033[1;32mok\\033[0;39m ]";
regras_mac
gera_arquivos
fi
done

} # libera_acesso_nat()

function libera_acesso_valido ()
{

# Inicia loop para cada linha do arquivo de usuarios
for USUARIO in `cat $USUARIOS_VALIDOS` ; do
le_dados
if [ $situacao != b ] ; then
# Ecoa na tela a mensagem de habilitacao do cliente
#echo -e "Habilitando: \\033[1;34m$cliente\\033[0;39m com o IP: \\033[1;33m$ip\\033[0;39m limitado à: \\033[1;37m$velocidade\\033[0;39m Kbps [ \\033[1;32mok\\033[0;39m ]";
regras_mac
gera_arquivos
# Se o cliente estiver bloqueado redireciona para pagina de aviso
fi
done

} # libera_acesso_valido()
function libera_acesso_sem_encaminhamento ()
{

# Inicia loop para cada linha do arquivo de clientes
for registro in `cat $clientes_valido` ; do
le_dados
if [ $situacao != b ] ; then
# Ecoa na tela a mensagem de habilitacao do cliente
#echo -e "Habilitando: \\033[1;34m$cliente\\033[0;39m com o IP: \\033[1;33m$ip\\033[0;39m limitado à: \\033[1;37m$velocidade\\033[0;39m Kbps [ \\033[1;32mok\\033[0;39m ]";
regras_mac
gera_arquivos
# Se o cliente estiver bloqueado redireciona para pagina de aviso
fi
done

} # libera_acesso_sem_encaminhamento()


zera_regras
ok
regras_iniciais
ok
redireciona_portas
ok
bloqueia_ips
ok
bloqueia_portas
ok
libera_smtp
ok
libera_acesso_valido
ok
libera_acesso_nat
ok
servidores_sem_proxy
ok
usuarios_sem_proxy
ok
regras_finais
ok

# Rele o arquivo de configuracaoo do Squid
squid -k reconfigure
# Para a limitação de banda
/usr/sbin/cbqinit stop
# Inicia a limitação de banda
/usr/sbin/cbqinit start
# Apaga arquivo para identificar que ja esta rodando
rm -f /var/run/acesso.run