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

#!/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 ;

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

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

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

#!/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>

# 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

# 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 ;

done

# 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

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

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

done

} # libera_acesso_sem_encaminhamento()

zera_regras

regras_iniciais

redireciona_portas

bloqueia_ips

bloqueia_portas

libera_smtp

libera_acesso_valido

libera_acesso_nat

servidores_sem_proxy

usuarios_sem_proxy

regras_finais

# 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

Uma resposta para “Continuação da saga Linuxer”

Mateus disse:

23 de maio de 2016 às 02:55

Obrigado Daniel por compartilhar suas experiências, realmente a Mikrotik através das RouterBords e do RouterOS deram uma grande força para os pequenos provedores, possibilitando atender vários lugares onde as grandes teles não chegavam ou chegavam com má qualidade de serviço. Até a próxima história, abraço.

Responda

Uma resposta para “Continuação da saga Linuxer”

Deixe uma resposta Cancelar resposta