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

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

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

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

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.

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

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?

aqui

Como instalar:

aqui

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.