segunda-feira, 30 de novembro de 2015

Firewall Shell script


Firewall Shell script (parte 6) - Final

Recaptulando temos o seguinte Arquivo de Firewall:

#!/bin/sh

#Firewall Netfilter desenvolvido por HenriqueKbs

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

#Path
IPT="/sbin/iptables"

#Apagar regras atuais
$IPT --flush
$IPT --delete-chain
$IPT -t nat -F
$IPT -t mangle -F

#Política das cadeias na tabela FILTER
$IPT -P INPUT ACCEPT
$IPT -P FORWARD ACCEPT
$IPT -P OUTPUT ACCEPT

#Habilitar módulos do netfilter
modprobe ipt_mac
modprobe ipt_ttl
modprobe iptable_nat
modprobe iptable_mangle
modprobe ipt_limit
modprobe ipt_state
modprobe ipt_tos

#Paths
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 --srcrange 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

#Logs do sistema
$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:"

#Limitar acesso a netbios, multcast e broadcast
$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

#Masqueramento de pacotes
$IPT -t nat -A POSTROUTING -o $WAN -s $REDE -j MASQUERADE

#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 na tabela nat
$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 na tabela nat
$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 ao DNS, pela FORWARD
$IPT -A FORWARD -i eth1 -o eth0 -p udp -s $REDE -m iprange --dst-range /
189.38.95.95-189.38.95.96 --sport 1024:65535 --dport 53 -j $AP
$IPT -A FORWARD -i eth0 -o eth1 -p udp -m iprange --src-range /
189.38.95.95-189.38.95.96 -d $REDE --sport 53 --dport 1025:65535 -j $AP

#Liberar acesso a http, para a rede, pela FORWARD
$IPT -A FORWARD -i eth1 -o eth0 -p tcp -m tcp -s $REDE -d 0/0 /
--sport 1024:65535 --dport 80 -m state --state NEW,ESTABLISHED -j $AP
$IPT -A FORWARD -i eth0 -o eth1 -p tcp -m tcp -s 0/0 -d $REDE /
--sport 80 --dport 1024:65535 -m state --state ESTABLISHED -j $AP

#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

#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

#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

#Fechando o laço
$IPT -A C_ARP -p udp -m udp --dport 1:1024 -j $DP
$IPT -A C_ARP -p tcp -m tcp --syn -j $DP

$IPT -A INPUT -p udp -m udp --dport 1:1024 -j $DP
$IPT -A INPUT -p tcp -m tcp --syn -j $DP

$IPT -A FORWARD -p udp -m udp --dport 1:1024 -j $DP
$IPT -A FORWARD -p tcp -m tcp --syn -j $DP

#Bloqueio opcional
$IPT -t mangle -I PREROUTING -i $WAN -s 0/0 -p tcp -m multiport \
! --dports 22,3389 -j $DP

iptables-save


echo "======================="
echo "== Regras de Firewall Ativadas... =="
echo "======================="

# EOF







     Termino do Firewall








     Referências bibliográficas:
    
     Programção Shell Linux - Julio Cezar Neves
    
     devmedia.com.br - Wagner Tadeu Mendes
    
     http://www.netfilter.org/documentation/index.html
























Postado por às Nenhum comentário:

quinta-feira, 12 de novembro de 2015

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













Postado por às Nenhum comentário:

terça-feira, 3 de novembro de 2015

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



Postado por às Nenhum comentário:

sexta-feira, 30 de outubro de 2015

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







Postado por às Nenhum comentário:

quarta-feira, 28 de outubro de 2015

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












Postado por às Nenhum comentário:

terça-feira, 27 de outubro de 2015

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.







 
 
Postado por às Nenhum comentário:

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






Postado por às Nenhum comentário:

sexta-feira, 23 de outubro de 2015

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




Postado por às Nenhum comentário:

terça-feira, 22 de setembro de 2015

Protocolos TCP e UDP



 TCP (Transmission control protocol) e UDP (User Datagram Protocol, são os principais protocolos da camada de Transporte do modelo OSI (Open Systems Interconection), são responsáveis pela segmentação de pacotes pela rede.
O protocolo TCP é orientado a conexão, possui controle de erros, com três fases distintas:
1 - Inicialização de sessão
2 - Manutenção de sessão
3 - Finalização de sessão


O protocolo UDP, não orientado a conexão, não possui controle de erros. É menos confiável, porém sua entrega de dados é mais rápida.


 Na prática, na estrutura do netfilter (a camada de transporte em geral), são usadas portas para cada tipo de serviço. Existem 65535 portas, tanto TCP e UDP que podem ser usadas na segmentação de pacotes numa rede Ethernet.
Uma forma simples de saber qual porta está vinculada a qual tipo de serviço, é consultar o arquivo “/etc/services”, em qualquer distribuição Linux:
#cat /etc/services | grep telnet
#cat /etc/services | grep tftp
#cat /etc/services | grep http


Quando criamos uma regra no iptables, para compreender a sintaxe de uma regra específica, temos basicamente:
#iptables -t filter -A INPUT -i eth0 -p tcp -s 0/0 -d 192.168.1.100 --sport 1024:65535 --dport 3389 -j ACCEPT


-Adicionando na cadeia INPUT, entrando pela interface eth0 ,qualquer endereço de origem, com destino ao ip 192.168.1.100, com porta TCP de origem dentro do range de 1024 à 65535 com destino a porta TCP 3389 (Terminal Services) é aceito.


Entendendo a utilização de portas TCP quando se inicializa uma conexão.

Acesso há um Web Site por exemplo:
 Sua porta TCP de origem sempre será alta (de 1024 à 65535) aleatório, dentro desse range, não dá para especificar exatamente qual, a porta de destino será a TCP 80 (pedido de SYN)
 Quando o Servidor Web te retorna uma resposta (ACK), ele utiliza a porta TCP 80 de origem e alguma porta alta TCP, aleatória dentro do range de 1024 à 65535 para o destino. Por isso, se utilizarmos alguma regra na cadeia FORWARD (ByPass) temos que criar uma regra simétrica, na ida e na volta, exemplo:
#iptables -A FORWARD -i eth1 -o eth0 -p tcp -s 172.16.1.0/24 -d 0/0 --sport 1024:65535 --dport 80 -j ACCEPT
#iptables -A FORWARD -i eth0 -o eth1 -p tcp -s 0/0 -d 172.16.1.0/24 --sport 80 --dport 1024:65535 -j ACCEPT



Postado por às Nenhum comentário:

Descompactar arquivos no Linux



Arquivo .tar

Opções e sintaxe:
-c cria um novo arquivo .tar e adiciona a ele os arquivos a serem comprimidos.
-f indica que o destino é um arquivo em disco.
-p preserva permissões originais dos arquivos, quando descompactados.
-r adiciona os arquivos especificados no final do arquivo .tar, sem criar um novo.
-t lista o conteúdo do arquivo .tar.
-u adiciona os arquivos especificados ao arquivo .tar, se estes não sejam duplicados.
-v mostra o nome de cada arquivo processado.
-x retira os arquivos agrupados no arquivo .tar.


Compactar arquivo .tar
tar -cf etc_bkp.tar /etc/*


Descompactar arquivo .tar
tar -xvf etc_bkp.tar


Descompactar arquivo tar.gz
tar -vzxf arquivo.tar.gz


Descompactar arquivo tar.bz2
tar -jxvf arquivo.tar.bz2


Descompactar arquivo bz2
bunzip arquivo.bz2


Descompactar arquivo tar.xz

tar -xJf arquivo tar.xz



Descompactar arquivo zip
gunzip arquivo.zip


Visualizar arquivo zip
zcat arquivo.zip




Postado por às Nenhum comentário:

quinta-feira, 3 de setembro de 2015

IP Internet Protocol



O protocolo IP (Internet Protocol)


 O protocolo IP (Internet Protocol) baseia-se num endereço lógico de 32 bits, formado por quatro octetos de 8 bits.
 Para entender o endereço IP (versão IPV4), deve-se entender sua estrutura binária, que compreende basicamente, os quatro octetos.
Cada octeto possui a seguinte estrutura:
   I       I       I       I        I       I       I       I
128    64     32    16      8      4      2      1
Em base10 seria o numeral 255

 I       0       0       0       0       0       0       I
128   0       0       0       0       0       0       1
Em base10 seria o numeral 129


 Os endereços IPs estão divididos em classes, e cada classe possui seu respectivo range. Junto com o IP é definido a sua máscara de rede, estes dois parâmetros definem, com exatidão três informações importantes: Endereço Lógico, Endereço de Rede e Número de Hosts


Classe/Range   Máscara de Rede Bits
A – 1 ~ 126      255.0.0.0             R.H.H.H
B – 128~191    255.255.0.0          R.R.H.H
C – 192~223    255.255.255.0       R.R.R.H
D – 224~239    Multcast
127.0.0.0 Loopback
 
 Nestes endereços estão inclusos todos os endereços IPs válidos, tanto os Privados como os Públicos (endereços de DNS válidos para Internet).


Entendendo melhor os Endereços de IPs
RFC 1918 (destinado para redes privadas)


 São os seguintes endereços destinados para redes locais (privadas), que não se destinam a rotear pela Internet:
10.0.0.0 ~ 10.255.255.255 (10.0.0.0/8)
172.16.0.0 ~ 172.31.255.255 (172.16.0.0/12)
192.168.0.0 ~ 192.168.255.55 (192.168.0.0/16)


 Para entender melhor o significado de /8, /12 e /16, veremos mais adiante o conceito de Sub Redes.


Endereços de rede Privados Class Full:

Classe Endereço         Máscara de rede  N. de Redes  N. de Hosts
A         10.0.0.0            255.0.0.0              1                  16777214
B         172.16.0.0~31  255.255.0.0         16                  65534
C         192.168.0.0      255.255.255.0      1                   254
 Analisando a Máscara de Rede é possível observar a possibilidade do número de Hosts possíveis em determinada rede.
 Classe A, equivale aos três últimos zeros da máscara de rede 255.0.0.0, cada 0 equivale a 8 Bits, então com três zeros temos 24 Bits. O cálculo de Hosts, é 2 elevado à 24 que resulta em 16777216, subtrai-se dois (rede e broadcast), resulta em 16777214 endereços para Hosts possíveis.
  Classe B, os dois últimos zeros, representam o número de Hosts possíveis, no caso 2 elevado a 16, resulta em 65534 Hosts possíveis
 Classe C, o último 0 do octeto representa a porção de Hosts. 2 elevado a 8, resulta em 254 Hosts possíveis.


 Sub Redes, conceito de VLSM (Variable Lenght Subnet Mask) e CIDR (ClassLess Inter-Domain Routing).
 Estes termos se referem a prática de “escovar Bits”, dito no jargão popular. O IPV4 está em seu limite, com tantos dispositivos IPortáveis, já está praticamente esgotado. Para aproveitar ao máximo os endereços existentes, a solução é quebrar os octetos, usando o conceito de Sub Redes.

 Lembrando o conceito básico de Máscaras Class Full temos:
Classe A - 255.0.0.0/8
Classe B - 255.255.0.0/16
Classe C - 255.255.255.0/24
 A Máscara de rede, fora desses parâmetros básicos, entra no conceito de Sub Redes.

 Para facilitar a compreensão do conceito de Sub Redes iremos exemplificar, com endereçamento privado classe C /24 em diante.
  O temo /24, se refere a máscara de rede padrão 255.255.255.0, porque temos, olhando da esquerda para a direita, exatos 24 Bits (8+8+8) referente a porção de rede e sobram 8 bits para a porção de hosts.
 Um endereço de rede comum, 192.168.1.0/25 por exemplo:
 Este /25 se refere a máscara de rede 255.255.255.255.128.
 Foi sequestrado 1Bit da porção Host para a porção Rede, no último octeto temos:
I       0        0        0        0       0       0       0
128  0        0        0        0       0       0       0

 Os últimos 7 Bits (todos os zeros) são para a porção Hosts, que resulta em 2 elevado a 7, que é igual à 128, desconta o endereço de rede e o de broadcast, temos 126 Hosts possíveis com a máscara de rede /25. 

 Vamos mudar a máscara de rede para 192.168.1.128/26
O termo /26 equivale a máscara de rede 255.255.255.192
No último octeto temos:
I       I       0       0       0       0       0       0
128 64     0        0       0       0       0       0
Sobraram 6 Bits para a porção Host, o que resulta em 62 endereços válidos.

 Usaremos agora o endereço 192.168.1.192/27
O termo /27 equivale a máscara de rede 255.255.255.224
No último octeto temos:
I       I       I       0       0       0       0       0
128  64    32     0       0       0       0       0
Sobraram 5 Bits para a porção Host, o que resulta em 30 endereços válidos.


 Agora vamos usar o endereço 192.168.1.224/28
O termo /28 equivale a máscara de rede 255.255.255.240
No último octeto temos:
I       I       I       I       0       0       0       0
128  64    32    16      0       0       0       0
Sobraram 4 Bits para a porção Host, o que resulta em 14 endereços válidos.

 Usaremos agora o endereço 192.168.1.240/29
O termo /29 equivale a máscara de rede 255.255.255.248
No último octeto temos:
I       I       I       I       I       0       0       0
128 64    32     16     8       0       0       0
Sobraram 3 Bits para a porção Host, o que resulta em 6 endereços válidos.

 Vamos usar agora o endereço 192.168.1.248/30
O termo /30 equivale a máscara de rede 255.255.255.252
No último octeto temos:
I       I        I       I       I       I       0       0
128  64    32     16     8      4       0       0
Sobraram 2 Bits para a porção Host, o que resulta em 2 endereços válidos (Link de Wan)


Conclusão:
 Desse modo, manipulando os Bits, foi possível com apenas um endereço de Rede 192.168.1.0/24 criar as seguintes Sub Redes independentes:
Sub Rede 1 – 192.168.1.0/25 (para 126 Hosts)
Sub Rede 2 – 192.168.1.128/26 (para 62 Hosts)
Sub Rede 3 – 192.168.1.192/27 (para 30 Hosts)
Sub Rede 4 – 192.168.1.224/28 (para 14 Hosts)
Sub Rede 5 – 192.168.1.240/29 (para 6 Hosts)
Sub Rede 6 – 192.168.1.248/30 (para 2 Hosts)

Sub Rede  Endereço de Rede  Endereço de Broadcast
1               192.168.1.0            192.168.1.127
2               192.168.1.128        192.168.1.191
3               192.168.1.192        192.168.1.223
4               192.168.1.224        192.168.1.139
5               192.168.1.240        192.168.1.247
6               192.168.1.248        192.168.1.251
































Postado por às Nenhum comentário:

quinta-feira, 11 de junho de 2015

New Debian "Jessie" Screeshots & Simple Firewall


Debian "Jessie" with Mate 1.8.2 interface:



I liked, stable, fast and modern visulal. But it is not yet mature.


Firewall Script (for workstation, one NIC):

#!/bin/sh
#Firewall netfilter desenvolvido por Henrique Kbs

iptables -F
iptables -X
iptables -t nat -F
iptables -t mangle -F

IPT="/sbin/iptables"

$IPT -P INPUT DROP
$IPT -P FORWARD DROP
$IPT -P OUTPUT ACCEPT

AP="ACCEPT"
DP="DROP"
REDE="192.168.1.0/24"
SERVER="192.168.1.1/32"

$IPT -N C_NIC

$IPT -A INPUT -i eth0 -j C_NIC
$IPT -A FORWARD -i eth0 -j C_NIC
$IPT -A FORWARD -o eth0 -j C_NIC

$IPT -A OUTPUT -p tcp -m state --state NEW,ESTABLISHED -j $AP
$IPT -A OUTPUT -p icmp --icmp-type 8 -m limit --limit 2/s -j $AP
$IPT -A OUTPUT -o lo -j $AP

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

$IPT -A C_NIC -p udp --sport 1024:65535 --dport 53 -j $AP
$IPT -A C_NIC -p udp --sport 53 --dport 1024:65535 -j $AP

$IPT -A C_NIC -p tcp --sport 1024:65535 --dport 80:443 -j $AP
$IPT -A C_NIC -p tcp --sport 80:443 --dport 1024:65535 -j $AP

$IPT -A C_NIC -p tcp --sport 1024:65535 --dport 22 -j $AP
$IPT -A C_NIC -p tcp --sport 22 --dport 1024:65535 -j $AP

$IPT -A C_NIC -p tcp --sport 1024:65535 --dport 3389 -j $AP
$IPT -A C_NIC -p tcp --sport 3389 --dport 1024:65535 -j $AP

$IPT -A C_NIC -p tcp --sport 1024:65535 --dport 1:65535 -j $AP
$IPT -A C_NIC -p tcp --sport 1:65535 --dport 1024:65535 -j $AP

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

$IPT -A C_NIC -m limit --limit 1/s -p udp --sport 137:138 --dport 137:138 -j $AP

$IPT -A C_NIC -m limit --limit 1/s -d 224.0.0.0/24 -j $AP

$IPT -A C_NIC -m limit --limit 1/s -d 192.168.1.255 -j $AP

$IPT -A C_NIC -m limit --limit 1/s -d 255.255.255.255 -j $AP

$IPT -A C_NIC -m limit --limit 7/m --limit-burst 1 -j LOG --log-prefix "FW_ALL_NIC_log:"

$IPT -A C_NIC -p tcp --syn -j $DP
$IPT -A C_NIC -p udp --dport 0:1024 -j $DP

$IPT -t nat -A POSTROUTING -o eth0 -j MASQUERADE

iptables-save

watch -n 1 -d iptables -nvL




#apt-cache search comments

Postado por às Nenhum comentário:

quarta-feira, 27 de maio de 2015

Configuração de múltiplas placas de rede no Linux Debian e derivados



Mudando a ordem das eth’s

Quando se trabalha com várias placas de rede no Linux, as vezes por algum motivo, podem mudar a ordem das placas de rede configuradas no sistema operacional, ou pode queimar uma placa, e quando fizer a troca ela recebe outra numeração.
Para colocar a ordem das eth’s ao seu gosto, basta editar o arquivo:
“/etc/udev/rules.d/70-persistent-net.rules”
Neste arquivo o mac address (endereço físico) da placa de rede está atrelado ao número referente a eth (eth0, eth1, eth2 etc) do sistema.


Antes de começar, para não se perder, é bom saber todas as interfaces, os endereços físicos, lógicos e numeração das eth’s. Para isso de o comando:
#ifconfig -a



Para mudar a ordem das eth’s façam o seguinte:
Primeiramente é sempre bom fazer uma cópia de segurança do arquivo original:
#cd /etc/udev/rules.d
#cp 70-persistent-net.rules 70-persistent-net.rules_bkp
Depois de fazer a cópia do arquivo é só editar, mudando a ordem das eth’s, conforme suas necessidades (sempre se baseie no que foi mostrado no comando ifconfig):
#nano 70-persistent-net.rules




A outra forma de se fazer isso; é preciso instalar o pacote “ifrename”
#apt-get update
#apt-get install ifrename
Depois de instalado, é preciso criar um arquivo “iftab” em /etc:
#cd /etc
#touch iftab
#nano iftab
Depois é só editar o arquivo “iftab” colocando o seguinte:
Eth0 mac a8:b1:12:00:60:9f
Eth1 mac 92:f5:52:03:90:39
Eth2 mac 99:c3:12:00:55:54


É só atrelar o número da eth ao mac address da placa de rede.





Postado por às Nenhum comentário:

quarta-feira, 20 de maio de 2015

Roteador WiFi hostapd Linux (parte 2)


O Firewall da rede

São necessárias duas placas de rede, geralmente a eth0 (placa de rede onboard) e wlan0, que é a placa de rede wireless destinada a rede WiFi.
A rede cabeada eth0, pode estar configurada com ip fixo (da sua rede local) ou receber um ip via DHCP (do modem ligado à internet, por exemplo). O arquivo de configuração de rede no debian é:
/etc/network/interfaces

Configure, conforme o IP da sua rede.


Para criar o Firewall de rede:
Acesse o diretório /root
# cd /root
Crie o arquivo firewall.sh
#touch firewall.sh
Torne-o executável
#chmod +x firewall.sh
Depois é só colocar o script no arquivo firewall.sh
#nano firewall.sh
Para torna-lo executável no boot do sistema
#nano /etc/rc.local
inserir
/root/firewall.sh


Agora vamos ao script do firewall:

#!/bin/sh
#Firewall desenvolvido por HenriqueKbs
#Habilitando os modulos
modprobe ipt_multiport
modprobe ipt_limit
modprobe iptable_nat
#Alias da rede
IPT="/sbin/iptables"
AP="ACCEPT"
DP="DROP"
RJ="REJECT"
REDE1="172.1.1.0/24"
REDE2="192.168.254.0/29"
SERVER="172.1.1.142"
SERVER2="192.168.254.1"
HOST2="192.168.254.2"
HOST3="192.168.254.3"
HOST4="192.168.254.4"
DNS1="189.38.95.96"
DNS2="189.38.95.95"
DNS3="200.221.11.98"
DNS4="200.147.225.105"
WAN="wlan0"
#Regras do Firewall
#Limpa as cadeias existentes
iptables -F
iptables -X
iptables -t nat -F
iptables -t mangle -F
#Criando novas cadeia
$IPT -N C_SSH
$IPT -N C_DNS
$IPT -N C_ZXY
#regras de Bloqueio
$IPT -A INPUT -p tcp --dport 23 -j DROP
$IPT -A FORWARD -i $WAN -m iprange --src-range 192.168.254.5-192.168.254.6 -j DROP
#Criacao de regras para as cadeias novas
iptables -A INPUT -p tcp -m tcp --sport 1024:65535 --dport 22 -j C_SSH
iptables -A FORWARD -p udp -s $DNS1 --sport 53 --dport 1024:65535 -j C_DNS
iptables -A FORWARD -p udp -s $DNS2 --sport 53 --dport 1024:65535 -j C_DNS
iptables -A FORWARD -p udp -s $DNS3 --sport 53 --dport 1024:65535 -j C_DNS
iptables -A FORWARD -p udp -s $DNS4 --sport 53 --dport 1024:65535 -j C_DNS
1024:65535 -j C_DNS
iptables -A FORWARD -p udp -m udp --sport 1024:65535 --dport 53 -j C_DNS
iptables -A FORWARD -p udp -m udp --sport 53 --dport 1024:65535 -j $AP
iptables -A INPUT -p udp -s 0/0 -d $SERVER --sport 53 -j C_DNS
iptables -A INPUT -p udp -s 0/0 -d $SERVER2 --sport 53 -j C_DNS
$IPT -A INPUT -i eth0 -j C_ZXY
#Chhain SSH
iptables -A C_SSH -s $REDE1 -d $SERVER -j $AP
iptables -A C_SSH -p tcp --dport 22 -m limit --limit 1/min --limit-burst 1 -j LOG --log-prefix "FW_SSH_log:"
iptables -A C_SSH -j $DP
#chain DNS
iptables -A C_DNS -d $REDE1 -j $AP
iptables -A C_DNS -s $REDE1 -j $AP
iptables -A C_DNS -d $HOST2 -j $AP
iptables -A C_DNS -s $HOST2 -j $AP
iptables -A C_DNS -d $HOST3 -m limit --limit 2/s --limit-burst 1 -j $AP
iptables -A C_DNS -s $HOST3 -m limit --limit 2/s --limit-burst 1 -j $AP
iptables -A C_DNS -s $HOST4 -j $AP
iptables -A C_DNS -d $HOST4 -j $AP
iptables -A C_DNS -m limit --limit 1/min --limit-burst 1 -j LOG --log-prefix "FW_DNS_log:"
iptables -A C_DNS -j $DP
#Chain ZXY
$IPT -A C_ZXY -i lo -s 127.0.0.1 -j $AP
$IPT -A C_ZXY -i $WAN -p udp -m udp -s $REDE2 --sport 68 --dport 67 -j $AP
#iptables -A C_ZXY -i eth0 -p tcp -m tcp --dport 6346 -j REJECT
#Regras para cadeia OUTPUT
iptables -A OUTPUT -o lo -j $AP
iptables -A OUTPUT -o $WAN -p udp -s $SERVER2 -d $HOST2 --sport 67 --dport 68 -j $AP
iptables -A OUTPUT -p tcp -m tcp --sport 1024:65535 --dport 443 -j $AP
iptables -A OUTPUT -p tcp -m tcp --sport 1024:65535 --dport 80 -j $AP
iptables -A OUTPUT -p udp -m udp --sport 1024:65535 --dport 53 -j $AP
iptables -A OUTPUT -p udp -m udp --sport 67 --dport 68 -j $AP
iptables -A OUTPUT -p tcp -m tcp --sport 22 --dport 1024:65535 -j $AP
iptables -A OUTPUT -p icmp ! --icmp-type 0 -m limit --limit 2/s -j $AP
iptables -A OUTPUT -p udp --dport 1024:65535 -m limit --limit 5/s --limit-burst 10 -j $AP
iptables -A OUTPUT -p tcp -m state --state NEW -m limit --limit 3/s --limit-burst 10 -j $AP
iptables -A OUTPUT -p tcp -m state --state RELATED -m limit --limit 4/s --limit-burst 10 -j $AP
iptables -A OUTPUT -p tcp -m state --state ESTABLISHED -m limit --limit 2/s --limit-burst 10 -j $AP
#Regras para cadeia Input
iptables -A C_ZXY -d 172.1.1.255 -m limit --limit 3/s -j $AP
#Regras para tabela Nat
iptables -t nat -A POSTROUTING -p tcp -m tcp -j MASQUERADE --to-ports 1024-10240 -s 172.1.1.0/24
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
iptables -t nat -A OUTPUT -o lo -j $AP
# Accept inbound ICMP messages
$IPT -A INPUT -p ICMP ! --icmp-type 8 -m limit --limit 2/s -j ACCEPT
#Regras na Forward
echo 1 > /proc/sys/net/ipv4/ip_forward
#iptables -P FORWARD DROP
$IPT -A FORWARD -i $WAN -p tcp -s $SERVER2 -d 0/0 --sport 1024:65535 --dport 443 -m state --state NEW,ESTABLISHED -j $AP
$IPT -A FORWARD -p tcp -m tcp -s 0/0 -d $SERVER2 --sport 443 --dport 1024:65535 -j $AP
$IPT -A FORWARD -p tcp -s $REDE2 -m multiport --dports 80,443,809,8080 -j $AP
$IPT -A FORWARD -p tcp -d $REDE2 -m multiport --sports 80,443,809,8080 -m state --state NEW,ESTABLISHED -j $AP
$IPT -A FORWARD -i eth0 -p tcp -s $REDE1 -d 0/0 --sport 1024:65535 --dport 80 -m state --state ESTABLISHED -j $AP
$IPT -A FORWARD -i eth0 -p tcp -s 0/0 -d $REDE1 --sport 80 --dport 1024:65535 -m state --state ESTABLISHED -j $AP
$IPT -A FORWARD -p tcp -s $REDE2 -m multiport --dports 80,443,809,8080 -j $AP
$IPT -A FORWARD -p tcp -d $REDE2 -m multiport --sports 80,443,809,8080 -m state --state NEW,ESTABLISHED -j $AP
$IPT -A FORWARD -i eth0 -p tcp -s $REDE1 -m multiport --dports 443,809,995,993,587 -m state --state ESTABLISHED -j $AP
$IPT -A FORWARD -i eth0 -p tcp -d $REDE1 -m multiport --sports 443,809,995,993,587 -m state --state ESTABLISHED -j $AP
$IPT -A FORWARD -i $WAN -p udp -s $REDE2 -d 0/0 --sport 1024:65535 --dport 123 -j $AP
$IPT -A FORWARD -i eth0 -o $WAN -p tcp -m tcp -s 0/0 -d $HOST2 --sport 1024:65535 --dport 1024:65535 -m state --state ESTABLISHED -j $AP
$IPT -A FORWARD -i $WAN -o eth0 -p tcp -m tcp -s $HOST2 -d 0/0 --sport 1024:65535 --dport 1024:65535 -m state --state NEW,ESTABLISHED -j $AP
$IPT -A FORWARD -i eth0 -o $WAN -p tcp -m tcp -s 0/0 -d $HOST3 --sport 1024:65535 --dport 1024:65535 -m state --state ESTABLISHED -j $AP
$IPT -A FORWARD -i $WAN -o eth0 -p tcp -m tcp -s $HOST3 -d 0/0 --sport 1024:65535 --dport 1024:65535 -m state --state NEW,ESTABLISHED -j $AP
$IPT -A FORWARD -p tcp -m tcp -d 0/0 --sport 5999:65535 --dport 1024:65535 -m state --state NEW,ESTABLISHED -j $AP
$IPT -A FORWARD -p tcp -m tcp -s 0/0 --dport 5999:65535 --sport 1024:65535 -j $AP
#Regras para bloqueio e Logs
iptables -A C_ZXY -m limit --limit 6/hour --limit-burst 1 -j LOG --log-prefix "FW_ZXY_log:"
iptables -A FORWARD -m limit --limit 1/min --limit-burst 1 -j LOG --log-prefix "FW_FORWARD_log:"
iptables -A OUTPUT -m limit --limit 6/hour --limit-burst 1 -j LOG --log-prefix "FW_OUTPUT_log:"
iptables -A C_ZXY -p tcp -m tcp --syn -j DROP
iptables -A FORWARD -i eth0 -p tcp -m tcp --syn -j DROP
iptables -A FORWARD -i $WAN -p tcp -m tcp --syn -j DROP
iptables -A FORWARD -m limit --limit 1/min --limit-burst 1 -j LOG --log-prefix "FW_UDP_FOR_log:"
iptables -A FORWARD -p udp -m udp --dport 1:1024 -j DROP 
#Tabela Mangle
$IPT -t mangle -I PREROUTING 1 -p tcp -s $REDE1 -m string --algo bm --string "batepapo" -j DROP
$IPT -t mangle -I PREROUTING 2 -p tcp -s $REDE1 -m string --algo bm --string "facebook" -j DROP
$IPT -t mangle -I PREROUTING 4 -p tcp -s $REDE1 -m string --algo bm --string ".mp3" -j DROP
$IPT -t mangle -I PREROUTING 5 -p tcp -s $REDE1 -m string --algo bm --string ".flv" -j DROP
iptables -t mangle -A INPUT -i $WAN -p tcp -m tcp -s $REDE2 --dport 1024:65535 --sport 443 -j TOS --set-tos 16
iptables -t mangle -A INPUT -i eth0 -p tcp -m tcp -s $REDE2 --dport 1024:65535 --sport 80 -j TOS --set-tos 16

iptables-save

echo "======================="
echo "== Regras de Firewall Ativadas... =="
echo "======================="

# EOF


Mudem conforme a configuração de rede apropriada.

Para executar o Firewall:
#./firewall.sh




#apt-cache search comments





Postado por às Nenhum comentário:

terça-feira, 19 de maio de 2015

Roteador WiFi hostapd Linux (parte 1)



Há no mercado, inúmeros modelos e fabricantes de roteadores wireless, então qual o intuito de se montar um computador para tal função? Simples, reaproveitar micros mais antigos, ter a possibilidade de recursos conhecidos, como Firewall IPtables, Proxy Squid, DHCP server, agendamento de tarefas com o crontab, tudo isso controlado por acesso remoto via SSH.
Outro problema, comum na maioria dos roteadores WiFi existentes no mercado, é a quantidade limitada de memória Ram. Dependendo do tamanho da rede e o número de usuários conectados a ela, com dispositivos móveis, a quantidade de memória Ram, é de fundamental importância para a estabilidade de conexões do roteador. Quando um dispositivo se conecta a um roteador wireless, este grava o endereço mac address de origem, quando se estabelece uma conexão, muitos dispositivos e inúmeras conexões podem saturar a memória Ram existente no roteador, se isso acontecer ele trava, para de funcionar.
A maioria dos roteadores WiFi existentes no mercado, possuem apenas 16 Mb de memória Ram, outros modelos com 32 Mb, alguns com 64 Mb e raramente modelos tops com 128 Mb de Ram.
Exemplo: Chip Wimbond w9425g6jh-5 de 16 Mb do router TPLink TL-WR941ND


Num Router hostapd Linux, você pode alocar facilmente, 1 GB, 2 GB, 4Gb de memória Ram, conforme suas necessidades e possibilidades.
Para montar um Router hostapd precisará de um micro estável, mais uma placa de rede wireless
Como está:

Lembrando, que deve se respeitar os padrões WiFi da placa de rede. Uma placa de rede wireless padrão 802.11G vai receber pacotes (RX) e enviar pacotes (TX) nos teóricos 54Mbps.
Se quiser mais velocidade, terá que usar uma placa de rede WiFi padrão 802.11N, que te dará teóricos 150Mbps de taxa de transferência de dados, se quiser mais, coloque uma placa com várias antenas.
Dê preferência para placas com chipset Broadcom ou Atheros, que funcionam bem, placas com chipset Ralink são horríveis.
Para esta experiência estou usando um core2due E2200com 1 GB de Ram. A placa de rede é igual à foto.
Primeiramente deve se instalar o sistema operacional, eu uso o Debian Squeeze, aconselho usar esta distro, pode ser o Wheeze versão netinst, uso sem a interface gráfica, mas se preferir pode usar, mas tem um consumo maior de Ram.


Onde baixar os pacotes?

Como instalar:

Depois de instalado e configurado o Sistema operacional vamos instalar os pacotes necessário para colocar no ar o Roteador WiFi Linux.
Logue-se como root:
#apt-get update
#apt-cache search hostapd
#apt-get install hostapd

Para instalar o Servidor DHCP:
#apt-get install isc-dhcp-server

Costumo usar o dnsmasq, para cache de resolução de nomes:
#apt-get install dnsmasq
Para o dnsmasq funcionar devidamente, coloque a seguinte linha no arquivo /etc/resolv.conf
“nameserver 127.0.0.1”

Edit o arquivo “/etc/dnsmasq.conf”
#nano /etc/dnsmasq.conf
Insira o seguinte comentário no início do arquivo: “listen-address=127.0.0.1”
Reiniciar o dnsmasq:
/etc/init.d/dnsmasq restart


Vamos configurar agora o servidor DHCP:
#Killall –9 dhcpd
Editar o arquivo “/etc/default/isc-dhcp-server”
#nano /etc/default/isc-dhcp-server
Coloque a sua interface, que receberá os ips por DHCP, no meu caso:

INTERFACES="wlan0"
Agora vamos editar o arquivo de configuração do servidor DHCP:

#nano /etc/dhcp/dhcpd.conf
O meu está assim:
Provavelmente terão que mudar o IP da rede e máscara de rede.
Depois de configurar o arquivo, é necessário inicializar o serviço:
#/etc/init.d/isc-dhcp-server start
Se não houver nenhum erro de configuração, o servidor DHCP está no ar.


Agora vamos ao Serviço hostapd (configurações do roteador WiFi)
#killall -9 hostapd (para desligar o serviço)
Veja se o arquivo /etc/defaut/hostapd a seguinte linha está descomentada:
 DAEMON_CONF="/etc/hostapd/hostapd.conf"


O principal arquivo de configuração do serviço hostapd é:
/etc/hostapd/hostapd.conf
Mas, antes de editá-lo faremos uma cópia de segurança
#cd /etc/hostapd
#cp hostapd.conf /etc/hostapd/hostapd.conf_orig
Criaremos outro arquivo no lugar:
#touch hostapd.conf
#nano hostapd.conf
O meu está assim:
 As linhas de comando mais importantes aí são:
ssid=o nome da rede WiFi
wpa_passphrase=senha para acesso à rede
Reinicie o serviço hostapd
#/etc/init.d/hostapd restart
Se não houver nenhum erro, seu roteador estará no ar.

Postado por às Nenhum comentário:
Assinar: Postagens (Atom)