pfSense 2.x - Limite de largura de banda de Download & Upload por IP em sua rede.

Adicionando um HD novo no FreeBSD ou pfSense 2.x

1 - Conecte o HD na máquina e verifique na bios se o mesmo foi reconhecido, se foi reconhecido, ligue o computador.

2 - Depois do sistema devidamente iniciado, prompt de comando usando o root, utilize o comando dmesg para descobrir o nome do dispositivo.
     
dmesg | tail

(Procure da0, da1, da2, ... como a última entrada. Usaremos da1 neste exemplo. Tenha muito cuidado e selecione a última entrada, ou você vai acabar de formatar seu disco rígido interno).

3 - Limpar nossa MBR no disco.

fdisk -i da1

 
 Do you want to change our idea of what BIOS thinks ? [n]  Press Enter
 Do you want to change it?[n] Press Enter
 Do you want to change it?[n] Press Enter
 Do you want to change it?[n] Press Enter
 Do you want to change it?[n] Press Enter
 Do you want to change the active partition? [n] Press Enter
 
 Should we write new partition table? [n] Press y

4 - Criar sistema de arquivos.

      newfs /dev/da1s1 [Não importa qual disco (da0, da1), a fatia é sempre s1]

5 - Montando seu HD para poder gravar arquivos nele

      mount /dev/da1s1 /mnt/seu_disco_novo

Para desmontar a unidade é somente digitar o seguinte comando: 

      umount /mnt/seu_disco_novo

Se desejar montar a unidade quando o FreeBSD ou o pfSense 2.x for iniciado é só editar o arquivo fstab.

Exemplo:

1 - Fazer backup do fstab por segurança.

     cp /etc/fstab/ /etc/fstab.bkp

2 - Modificar as permissões do fstab para aceitar a gravação após ser alterado.

      chmod 744 /etc/fstab

3 -  Editando o arquivo fstab com um editor de sua preferência, no meu caso usei o vi.

      vi /etc/fstab

      este é o meu arquivo fstab.

      # Device                Mountpoint      FStype  Options         Dump    Pass#
        /dev/da0s1a             /                       ufs       rw                     1       1
        /dev/da1s1              /newHD            ufs       rw                     2       2
        /dev/da0s1b             none                swap    sw                    0       0

    Acrescentei a linha que está em negrito, o /dev/da1s1 é por que o meu dispositivo é o da1 conforme explicado no passo 2 no comando dmesg. OBS: o  /newHD é o ponto de montagem que usei em meu servidor, você terá que informar o seu, de acordo com o que você criou.

4 - Volte as permissão do arquivo para o que estava antes

      chmod 444 /etc/fstab

5 - Reinicie seu FreeBSD ou o pfSense 2.x e pronto...... seu novo hd está montado automaticamente no boot.

Espero ter ajudado, grande abraço a todos.

Disco cheio servidor linux

Quando o disco do seu servidor linux estiver cheio e você quiser saber o que está ocupando mais espaço, a resposta pode ser obtida com o comando du e alguns atributos.

Um exemplo bem completo seria a sintaxe:

du -sch *

De forma que:
-s = Mostrará o sumário do diretório especificado. (Como usamos * todos os diretórios no caminho atual serão descritos)
-c = Mostra o total da listagem
-h = Exibe o tamanho em formatos amigáveis como K,M,G

Se você estiver buscando arquivos ou diretórios à partir de 1 Gb você pode adicionar o atributo grep, então o comando fica:
du -sch * | grep G

Agendar tarefas com o cron do Linux

O que é o cron?

O cron, é o agendador de tarefas do linux, que ao contrário do at, que só permite que executemos tarefas agendadas apenas uma única vez, o cron nos permite executar tarefas repetidamente, ou seja, todo dia, toda semana, ou em qualquer período pré-estabelecido.

Como usar o cron?

Para usar o cron, ou seja, agendar uma tarefa, precisamos editar o arquivo crontab. O caminho para este arquivo, na maioria das distribuições, é: /etc/crontab. Você pode agendar várias tarefas, para tanto você deve colocar um agendamento por linha.

A sintaxe de configuração para um agendamento no arquivo /etc/crontab, que é bem simples, é explicada a seguir.

(minutos) (horas) (dias do mês) (mês) (dias da semana) (usuário) (comando)

Onde:

minutos: Representa o minuto no qual o comando será executado. Aceita apenas números de 0 a 59.

horas: Representa a hora em que o comando será executado. Aceita apenas números de 0 a 23.

dias do mês: Define em que dia o comando será executado. Aceita apenas números de 0 a 31.

mês: Mês para o qual se agendou a execução do comando. Aceita apenas números de 1 a 12.

dias da semana: Define o dia da semana onde o comando será executado. Aceita apenas números de 1 a 7. Sendo 1 para segunda-feira e 7 para o domingo.

usuário: Definimos o usuário que executará o comando. Aceita apenas nomes de usuários previamente criados.

comando: Qualquer comando do sistema, scripts em geral, ou seja, qualquer arquivo que tenha permissão de execução.

Apresentados os campos, vamos aprender como trabalhar com eles de forma prática.

Vamos agendar um fictício script de backup para ser executado toda a noite às 22hs.

.---------------- minute (0-59)
|  .------------- hour (0-23)
|  |  .---------- day of month (1-31)
|  |  |  .------- month (1-12) OR jan,feb,mar,apr ...
|  |  |  |  .---- day of week (0-6) (Sunday=0 or 7) OR sun,mon,tue ...
|  |  |  |  |
*  *  *  *  *  command to be executed

 0   22  *     *   *    root /root/backup.sh

Note a presença do *. Ele pode ser interpretado como todos, ou todas. Neste caso, agendamos o nosso script para ser executado às 22h e 0m de todos os dias, todos os meses, todos os dias da semana. O usuário que executará o script será o root, e por fim, definimos qual script será executado.

—

Vamos a um próximo exemplo.

0 0,6,12,18 * * * root /root/backup.sh

Note a presença da vírgula. Ela pode ser traduzida por e. Neste exemplo podemos ler da seguinte forma: “root, execute o script /root/backup.sh todos os dias da semana, todos os meses, todos os dias, às 0,6,12 e 18hs e 0 minutos.”

—

Suponhamos que você seja supersticioso e queira agendar um backup geral do sistema toda sexta-feira 13 antes da meia noite. Para o cron, isto não é problema, como mostra o próximo exemplo.

0 23 13 * 5 root /root/backupGeral.sh

No exemplo acima, o script é executado às 23hs e 0min do dia 13 de todos os meses, porém somente quando neste dia 13, o dia da semana for 5(sexta-feira) .

—

Para agendarmos um comando para ser executado de 5 em 5 minutos por exemplo, podemos fazer da seguinte forma:

*/5 * * * * root /root/backup.sh

—

O cron também aceita agendamento por intervalos. Desta forma eu posso agendar um comando para ser executado da seguinte forma:

*/5 9-18 * * * root /root/backup.sh

Na linha acima, o comando /root/backup.sh é executado a cada 5 minutos, no intervalo das 9 as 18 hs de todos os dias, todos os meses, todos os dias da semana.

—

Existe um outro método, que eu considero como mais apropriado, para agendar tarefas no cron. Usando o comando crontab -e, editamos as tarefas apenas para o usuário corrente.

A sintaxe é bem semelhante, com apenas uma modificação: não informamos o usuário que executará o comando, já que esta tabela já é do usuário que executou o comando crontab -e.

Vejamos a sintaxe:

(minutos) (horas) (dias do mês) (mês) (dias da semana) (comando)

O restante é tudo igual ao que já foi explicado.

Para visualizar as tarefas agendadas para o usuário, digite o comando crontab -l.

O arquivo de configuração também aceita notação de comentário. Desta forma, toda a linha do arquivo que começar com o caractere #, será ignorada, ou seja, não será executada.



fonte : http://ubuntuforum-pt.org/index.php?topic=26791.0

Limpeza de Cache Squid do PfSense 2.x

/usr/local/etc/rc.d/squid.sh stop

rm -rf /var/squid/cache/

mkdir -p /var/squid/cache/

chown proxy:proxy /var/squid/cache/

chmod 750 /var/squid/cache/

squid -z

/usr/local/etc/rc.d/squid.sh start

Instalação do Openfire/Jabber no Ubuntu 12.04 Server

O Openfire é um servidor de chat corporativo baseado no protocolo XMPP, opensource e gratuito. Ele foi desenvolvido usando Java (o cliente dele, Spark, também é desenvolvido em Java) e é licensiado sob a Apache License 2.0. Esta solução, desenvolvida pela empresa Ignite Realtime, conta com interface web para gerenciamento, um cliente próprio (embora um pouco pesado, muito bem desenvolvido), armazenamento de todas as mensagens trocadas entre os usuários para auditoria, etc. Mas o melhor de tudo é que ela é extremamente simples de instalar e configurar.

Instalação do Openfire no Ubuntu

O primeiro passo é fazer o download do pacote .tar.gz. Para isso, vá até www.igniterealtime.org e clique no link “Download” no topo da página. Na página que se abre, localize “Openfire 3.7.1″ e clique no botão “Linux”. Agora, basta clicar na última opção e fazer o download do pacote .tar.gz.

Quando o pacote estiver na máquina onde você vai instalá-lo, descompacte e mova o diretório criado para /opt:
$ tar xzvf openfire_3_7_1.tar.gz
$ sudo mv openfire /opt

Pronto, agora para iniciar o serviço:
$ sudo /opt/openfire/bin/openfire start

Para verificar se tudo foi inicializado corretamente:
$ sudo /opt/openfire/bin/openfire status
The daemon is running

Depois disso, vamos configurar o banco de dados e iniciar a configuração via web.

Configuração do MySQL

Os passos descritos abaixo devem ser executados independentemente de qual distribuição você está usando. É no MySQL que o Openfire vai armazenar todos os dados que ele usa para funcionar corretamente.

Primeiro, faça o login no MySQL com o usuário root e crie o banco de dados openfire:
$ mysql -u root -p
password:
mysql> create database openfire;
mysql> exit

Agora, vá até o diretório resources do Openfire e importe o arquivo openfire_mysql.sql para o BD:
$ cd /opt/openfire/resources/database/
$ mysql -u root -p -D openfire < openfire_mysql.sql

Ok, tabelas criadas. Agora, precisamos criar um usuário do BD para o Openfire usar quando precisar acessá-lo. No meu caso, criei um usuário chamado “openfire”
mysql> CREATE USER openfire IDENTIFIED BY ‘openfire’;
mysql> REVOKE ALL ON *.* FROM openfire;
mysql> GRANT ALL ON openfire.* TO openfire@localhost;

Nas linhas acima, a senha é definida pela string entre ” após IDENTIFIED BY. Recomendo que coloque uma senha forte para não ter problemas. Pronto, banco de dados pronto pra trabalhar com o Openfire. Daqui pra frente toda a configuração será feita através da interface web.

Instalando Java Ubuntu 12.04

Instalando Java da Oracle no Ubuntu 12.04

Testado e Aprovado no meu caso o java da Sun não quis funcionar.

Acrescente o repositório ao sistema:

sudo add-apt-repository ppa:webupd8team/java

Atualize o índice de pacotes disponíveis:

sudo apt-get update

Por fim, instale o pacote:

sudo apt-get install oracle-jdk7-installer

Por fim se estiver com o navegador aberto reinicie e pronto para testar vamos recorrer ao site da Sun em:

http://www.java.com/pt_BR/download/testjava.jsp

fonte : http://ubuntu-rn.org/2012/?p=97

Ivory Framework HTML, CSS e JavaScript

Criar um site é muito complexo e as vezes não temos prazo suficiente para desenvolver tudo do zero. É neste cenário que a utilização de algum framework para agilizar o desenvolvimento torna-se essencial e crucial para o sucesso do projeto.

Hoje você irá conhecer uma nova solução para a criação de sites compatíveis comsmartphones, tablets e desktops com qualquer resolução ou tamanho de tela.

Ivory Framework – Sites Responsivos

Framework Responsivo

Ivory é um framework HTML, CSS e JavaScript para desenvolvimento de sites responsivos, ou seja, que se adaptam a qualquer tamanho de tela.

Com apenas um código seu projeto poderá ser visualizado em Smartphones, Tabletse computadores. Você não precisará mais se preocupar em codificar várias vezes a mesma página para que ela seja compatível com os mais variados dispositivos.

O Framework Ivory possui classes prontas para criação de formulários, listas,menus e botões. Criar novas páginas será simples e exigirá apenas algumas horas de estudo para dominar todos os recursos disponíveis.

Download e Informações

O download do Ivory pode ser feito por qualquer pessoa e sua utilização é livre. Após baixar o zip é recomendado que você veja o arquivo “index.html” para entender melhor o funcionamento do framework. Mas não se preocupe, tudo é muito fácil e simples.

• Demonstração Ivory
• Download Ivory

O Ivory ainda não pode ser comparado ao Bootstrap, mesmo assim é uma ótima solução para quem busca por um framework especializado na criação de sites responsivos. O mais interessante é que a curva de aprendizado é pequena. Você levará apenas algumas horas para compreender tudo.

Com certeza mais uma ótima ferramenta para agilizar o desenvolvimento de sites compatíveis com as mais diversas resoluções de tela. Nunca foi tão fácil criar um projeto para ser acessado pelo celular, tablet e até mesmo por TVs Inteligentes.

Gostou? Comente, compartilhe e curta nosso conteúdo para continuarmos no ar. Até!

Entendendo o funcionamento de um firewall e regras IPtables

Introdução 

O Firewall tem o objetivo proteger o servidor e a rede local contra acessos indesejados, tráfego indesejado, proteger serviços que estejam rodando no servidor e bloquear a passagem de coisas que você não deseja receber (como conexões vindas da Internet para sua rede local, evitando acesso aos dados corporativos de uma empresa ou a seus dados pessoais). A implementação de um bom firewall dependerá da experiência, conhecimentos de redes (protocolos, roteamento, interfaces, endereçamento, masquerade, etc), da rede local, e sistema em geral do Administrador de redes, a segurança de sua rede e seus dados dependem da escolha do profissional correto, que entenda a fundo o TCP/IP, roteamento, protocolos, serviços e outros assuntos ligados a rede. No kernel do Linux 2.4, foi introduzido o programa IPtables (também chamado de Netfilter) que substitui o ipchains dos kernels da série 2.2. Este novo programa tem como vantagem ser muito estável (assim como o ipchains e ipfwadm), confiável, permite muita flexibilidade na programação de regras pelo administrador do sistema, mais opções disponíveis ao administrador para controle de tráfego, controle independente do tráfego da rede local/entre redes/interfaces devido a nova organização das etapas de roteamento de pacotes.
O IPtables é um firewall em nível de pacotes e funciona baseado no endereço/porta de origem/destino do pacote, prioridade, etc. Ele funciona através da comparação de regras para saber se um pacote tem ou não permissão para passar. Em firewalls mais restritivos, o pacote é bloqueado e registrado para que o administrador do sistema tenha conhecimento sobre o que está acontecendo em seu servidor. Também pode ser usado para modificar e monitorar o tráfego da rede, fazer NAT (masquerading, source nat, destination nat), redirecionamento de pacotes, marcação de pacotes, modificar a prioridade de pacotes que chegam/saem do seu servidor, contagem de bytes, dividir tráfego entre máquinas, criar proteções anti-spoofing, contra syn flood, DoS, etc. O tráfego vindo de máquinas desconhecidas da rede pode também ser bloqueado/registrado através do uso de simples regras. As possibilidades oferecidas pelos recursos de filtragem iptables como todas as ferramentas UNIX maduras dependem de sua imaginação, pois ele garante uma grande flexibilidade na manipulação das regras de acesso ao sistema, precisando apenas conhecer quais interfaces o sistema possui, o que deseja bloquear, o que tem acesso garantido, quais serviços devem estar acessíveis para cada rede, e iniciar a construção de seu firewall.
Um firewall não funciona de forma automática (instalando e esperar que ele faça as coisas por você), é necessário pelo menos conhecimentos básicos de rede TCP/IP, roteamento e portas para criar as regras que farão a segurança de seu servidor. A segurança do servidor depende do controle das regras que serão criadas por você, as falhas humanas são garantia de mais de 95% de sucesso nas invasões.
Enfim o IPtables é um firewall que agradará tanto a pessoas que desejam uma segurança básica em seu servidor, quando administradores de grandes redes que querem ter um controle minucioso sobre o tráfego que passam entre suas interfaces de rede (controlando tudo o que pode passar de uma rede a outra), controlar o uso de tráfego, monitoração, etc.

Características do Netfilter/Iptables 
Segue abaixo algumas características do Firewall Netfilter/IPtables 

• Especificação de portas/endereço de origem/destino
• Suporte a protocolos TCP/UDP/ICMP (incluindo tipos de mensagens icmp)
• Suporte a interfaces de origem/destino de pacotes
• Manipula serviços de proxy na rede
• Tratamento de tráfego dividido em chains para melhor controle do tráfego que entra/sai da máquina e tráfego redirecionado.
• Permite um número ilimitado de regras por chain
• Muito rápido, estável e seguro
• Possui mecanismos internos para rejeitar automaticamente pacotes duvidosos ou mal formados.
• Suporte a módulos externos para expansão das funcionalidades padrões oferecidas pelo código de firewall
• Suporte completo a roteamento de pacotes, tratadas em uma área diferente de tráfegos padrões.
• Suporte a especificação de tipo de serviço para priorizar o tráfego de determinados tipos de pacotes.
• Permite especificar exceções para as regras ou parte das regras
• Suporte a detecção de fragmentos
• Permite enviar alertas personalizados ao syslog sobre o tráfego aceito/bloqueado.
• Redirecionamento de portas
• Masquerading
• Suporte a SNAT (modificação do endereço de origem das máquinas para um único IP ou faixa de IP's).
• Suporte a DNAT (modificação do endereço de destino das máquinas para um único IP ou fixa de IP's)
• Contagem de pacotes que atravessaram uma interface/regra
• Limitação de passagem de pacotes/conferência de regra (muito útil para criar proteções contra, syn flood, ping flood, DoS, etc).

Ficha técnica 
Pacote: IPtables 

• iptables - Sistema de controle principal para protocolos ipv4
• ip6tables - Sistema de controle principal para protocolos ipv6
• iptables-save - Salva as regras atuais em um arquivo especificado como argumento. Este utilitário pode ser dispensado por um shell script contendo as regras executado na inicialização da máquina.
• iptables-restore - Restaura regras salvas pelo utilitário iptables-save.

Entendendo as regras do IPtables 
Agora iremos entender a estrutura das regras iptables: 
Tabela FILTER 
É a tabela responsável pelos filtros dos pacotes. Ela se divide em 3 chains padrão. 
INPUT 
A chain INPUT é responsável por filtrar todo o tráfego que entra no firewall. 
FORWARD 
A chain FORWARD é responsável por filtrar todo o tráfego que passará pelo firewall, ou seja, todos os pacotes onde o NAT será aplicado. 
OUTPUT 
A chain OUTPUT é responsável por filtrar todo o tráfego que sairá pelo firewall. 
Tabela NAT 
É a tabela responsável pelo redirecionamento de pacotes. Ela também se divide em 3 chains. 
PREROUTING 
A chain PREROUTING é utilizada para alterar pacotes antes que os mesmos sejam roteados. 
POSTROUTING A chain POSTROUTING é utilizada pala alterar pacotes que já sofreram roteamento. 
Tabela MANGLE 
É a tabela responsável pela alteração de prioridade na entrada e saída de pacotes, baseando-se no tipo de serviço (TOS). É dividida em 2 chains. 
Comandos e ações 
Comandos 
-I 
Insere uma regra no início da lista. 
-A 
Adiciona uma regra no fim da lista. 
-D 
Apaga uma regra da lista. 
-L 
Lista as regras da lista. 
-P 
Altera a política padrão das Chains. 
-F 
Remove todas as regras da lista. 
-R 
Substitui uma regra da lista por outra. 
-N 
Cria uma nova chain na tabela especificada. 
-E 
Renomeia uma chain que foi criada com o comando -N. 
-X 
Apaga uma chain criada com o comando -N. 
Ações 
-p 
Especifica o protocolo ao qual a regra se aplicará. Também podemos utilizar o valor numérico que referencia o protocolo em /etc/protocol. Ex: -p gre ; -p 47 
-i 
Especifica a interface de entrada utilizada pela regra. Pode ser utilizada apenas com as chains INPUT e FORWARD. EX: -i eth0 ou -i eth+ para especificar todas as entradas. 
-o 
Especifica a interface de saída utilizada pela regra. Pode ser utilizada apenas com as chains FORWARD e OUTPUT. EX: -o eth0 
-s 
Especifica o endereço ou a rede de origem utilizada pela regra. Se não especificarmos a máscara de rede, o iptables utiliza a máscara padrão da classe C 255.255.255.0. Também podemos utilizar nomes DNS. Ex: -s 192.168.1.2; -s 192.168.1.0/255.255.255.0 domínio: exemplo.com.br 
-d 
Especifica o endereço ou a rede de destino utilizado pela regra. Se utiliza da mesma maneira que a ação -s. 
! 
Utilizado para especificar exceções. Ex: -s ! 192.168.1.6 # A regra se aplicaria a todos os ips que tivessem origem diferente de 192.168.1.6 
-j 
Utilizado para aplicar um alvo a regra, os mesmos podem ser ACCEPT, DROP, REJECT e LOG. Ex: -j ACCEPT 
--sport 
Especifica a porta de origem utilizada. Só podemos aplicar a ação quando estivermos tratando dos protocolos tcp e udp. Ex: -p tcp --sport 25 
--dport 
Especifica a porta de destino utilizada. Funciona da mesma forma que a ação --sport. Ex: -p tcp --dport 25. 
Alvos e módulos 
Alvos 
Quando temos um pacote que combinou com todas as opções da regra, necessitamos especificar um destino para o mesmo, como vimos anteriormente podemos especificar os seguintes alvos / destinos: 
ACCEPT 
Aceita a entrada ou passagem do pacote. 
DROP 
Descarta o pacote. 

REJECT 
Descarta o pacote, porém diferente de DROP, ele retorna uma mensagem ao emissor informando o que houve com o pacote. 
LOG 
Gera um log no sistema. 
RETURN 
Retorna o processamento da chain anterior. 
QUEUE 
Encarrega um programa de administrar o fluxo atribuído ao mesmo. 
SNAT 
Altera o endereço de origem do pacote. 
DNAT 
Altera o endereço de destino do pacote. 
REDIRECT 
Redireciona a porta do pacote juntamente com a opção --to-port. 
TOS 
Prioriza a entrada e saída de pacotes baseado em seu tipo de serviço. 
Podemos especificar em TOS os seguintes valores: 
16 ou 0x10 Espera mínima 
8 ou 0x08 Máximo processamento 
4 ou 0x04 Máxima confiança 
2 ou 0x02 Custo mínimo 
0 ou 0x00 Prioridade normal 
Módulos 
A utilização de módulos junto com o iptables é definida através da opção -m. Podemos utilizar os seguintes módulos: 
limit Impõe um limite de vezes que a regra poderá ser executada. 
state Utiliza o estado da conexão, que pode ser NEW, ESTABLISHED, RELATED, INVALID. 
mac Permite a utilização do endereço mac nas regras. 
multiport Permite a utilização de até 15 portas em uma única regra em conjunto com o --dport. string Verifica o conteúdo do pacote para aplicar a regra. 
owner Verifica o usuário que criou o pacote.

Considerações finais 
Para finalizar, temos que esclarecer algumas coisas sobre firewall do sistema GNU/Linux, que na realidade se chama Netfilter, e o IPtables são comandos interpretados pelo Netfilter no Kernel, por default já vem habilitado na maioria das distros.
Script Firewall com regras IPtables 
#!/bin/bash
#Função: Regras iptables de configuração do firewall
#Utilização:
#no Slackware -> /etc/rc.d/rc.firewall2 e colocar em /etc/rc.d/rc.local
#Start|Stop|Restart
#file executable: chmod 755 /etc/rc.d/rc.firewall2
#Variaveis
ifaceExt="eth0" #acesso internet
ifaceInt="eth1" #acesso intranet (LAN)
LAN="192.168.1.0/24" #rede local
#carrega módulos
/sbin/modprobe ip_nat
/sbin/modprobe ip_nat_ftp
/sbin/modprobe ip_queue
/sbin/modprobe ip_conntrack
/sbin/modprobe ip_conntrack_ftp
/sbin/modprobe ip_tables
/sbin/modprobe iptable_filter
/sbin/modprobe iptable_nat
/sbin/modprobe iptable_mangle
/sbin/modprobe iptable_raw
/sbin/modprobe ipt_state
/sbin/modprobe ipt_limit
/sbin/modprobe ipt_multiport
/sbin/modprobe ipt_mac
/sbin/modprobe ipt_string
start(){
echo "Firewall iniciando ..............................[OK]"
#Limpa as regras
iptables -F
iptables -X
iptables -Z
iptables -F INPUT
iptables -F OUTPUT
iptables -F FORWARD
iptables -t nat -F
iptables -t nat -X
iptables -t nat -Z
iptables -t mangle -F
iptables -t mangle -X
iptables -t mangle -Z
iptables -t raw -F
iptables -t raw -X
iptables -t raw -Z
#definindo as regras padrão
iptables -P INPUT DROP
iptables -P OUTPUT DROP
iptables -P FORWARD DROP
#Proxy(Squid) - Redirecionando tráfego porta 80 para porta 3128(Squid)
iptables -t nat -A PREROUTING -p tcp -m multiport -s $LAN --dport 80,443 -j REDIRECT --to-ports 3128
echo "Redirecionando tráfego porta 80 para porta 3128(Squid) "
#roteamento de pacotes
echo 1 > /proc/sys/net/ipv4/ip_forward
#compartilhamento de conexão
iptables -t nat -A POSTROUTING -s $LAN -o $ifaceExt -j MASQUERADE
iptables -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
echo "compartilhamento da rede ativo"
#Libera a interface de loopback(localhost)
iptables -A INPUT -i lo -j ACCEPT
#liberando acesso pela internet (eth0=ifaceExt)
iptables -A INPUT -s $LAN -p tcp --dport 53 -j ACCEPT
iptables -A INPUT -s $LAN -p udp --dport 53 -j ACCEPT
#liberando acessos de alguns serviços (eth1=ifaceInt) e serviço DNS/FTP/SSH/SAMBA apenas para rede interna
#chain INPUT
iptables -A INPUT -p tcp --dport 3128 -i $ifaceInt -j ACCEPT
#chain FORWARD
iptables -A FORWARD -p tcp --dport 3128 -i $ifaceInt -o $ifaceExt -s $LAN -j ACCEPT
iptables -A FORWARD -p tcp --dport 53 -i $ifaceInt -o $ifaceExt -s $LAN -j ACCEPT
iptables -A FORWARD -p udp --dport 53 -i $ifaceInt -o $ifaceExt -s $LAN -j ACCEPT
iptables -A FORWARD -p tcp --dport 21 -i $ifaceInt -o $ifaceExt -s $LAN -j ACCEPT
iptables -A FORWARD -p tcp --dport 20 -i $ifaceInt -o $ifaceExt -s $LAN -j ACCEPT
iptables -A FORWARD -p tcp --dport 110 -i $ifaceInt -o $ifaceExt -s $LAN -j ACCEPT
iptables -A FORWARD -p tcp --dport 25 -i $ifaceInt -o $ifaceExt -s $LAN -j ACCEPT
iptables -A FORWARD -p tcp --dport 3389 -i $ifaceInt -o $ifaceExt -s $LAN -j ACCEPT
iptables -A FORWARD -p tcp --dport 137:139 -i $ifaceInt -s $LAN -j ACCEPT
iptables -A FORWARD -p tcp --dport 137:139 -i $ifaceInt -s $LAN -j ACCEPT
#chain OUTPUT
iptables -A OUTPUT -p tcp --dport 80 -j ACCEPT
iptables -A OUTPUT -p tcp --dport 443 -j ACCEPT
iptables -A OUTPUT -p tcp --dport 53 -j ACCEPT
iptables -A OUTPUT -p udp --dport 53 -j ACCEPT
#técnica Port knocking para SSH
#Fases do Segredo (portas para liberar acesso ssh)
iptables -N INTO-FASE2
iptables -A INTO-FASE2 -m recent --name FASE1 --remove
iptables -A INTO-FASE2 -m recent --name FASE2 --set
iptables -A INTO-FASE2 -j LOG --log-prefix "INTO FASE2:"
iptables -N INTO-FASE3
iptables -A INTO-FASE3 -m recent --name FASE2 --remove
iptables -A INTO-FASE3 -m recent --name FASE3 --set
iptables -A INTO-FASE3 -j LOG --log-prefix "INTO FASE3:"
iptables -N INTO-FASE4
iptables -A INTO-FASE4 -m recent --name FASE3 --remove
iptables -A INTO-FASE4 -m recent --name FASE4 --set
iptables -A INTO-FASE4 -j LOG --log-prefix "INTO FASE4:"
iptables -A INPUT -p tcp -m recent --update --name FASE
#Determina o número de portas e o tempo que o ip ficará em cada uma das fases aguardando a próxima porta ser digitada
iptables -A INPUT -p tcp --dport 1002 -m recent --set --name FASE1
iptables -A INPUT -p tcp --dport 1004 -m recent --rcheck --seconds 15 --name FASE1 -j INTO-FASE2
iptables -A INPUT -p tcp --dport 1006 -m recent --rcheck --seconds 15 --name FASE2 -j INTO-FASE3
iptables -A INPUT -p tcp --dport 1008 -m recent --rcheck --seconds 15 --name FASE3 -j INTO-FASE4
#Aqui chegamos a FASE4, que é a última porta, onde será liberada a conexão com a
porta 22(ssh). O tempo está setado para 3600 segundos(1 hora).
Depois disso será fechada novamente para o ip em questão, lembrando que se ele ainda tiver logado não fará diferença, será fechada mesmo assim. Então aumente o tempo conforme desejado.
iptables -A INPUT -p tcp -s 0/0 --dport 22 -m recent --rcheck --seconds 3600 --name FASE4 -j ACCEPT
#fecha se tiver inativo por 3 minutos
#iptables -A INPUT -p tcp -s 0/0 --dport 22 -m limit --limit 3/minute --limit-burst 3 -j DROP
#Por último fechamos todos acessos a porta 22(ssh)
iptables -A INPUT -p tcp --dport 22 -j DROP
#algumas proteções
#Filtrando pacotes ICMP
echo "Filtrando pacotes contra ICMP Broadcast"
echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts
echo "Protegendo contra Ping da Morte..."
iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit 1/s -j ACCEPT
echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_all
iptables -A INPUT -p icmp -j DROP
#Bloqueando Tracerouters
#Bloqueia pacotes tcp malformados
iptables -A FORWARD -p tcp ! --syn -m state --state NEW -j DROP
iptables -A INPUT -m state --state INVALID -j DROP
iptables -A OUTPUT -m state --state INVALID -j DROP
iptables -A FORWARD -m state --state INVALID -j DROP
#Filtro das conexões estabelicidas
echo "Permitindo e filtrando conexões estabelecidas"
iptables -t filter -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -t filter -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
#iptables -t filter -A FORWARD -m state --state ESTABLISHED,RELATED -j ACCEPT
#Proteção contra Synflood
iptables -N syn-flood
iptables -A INPUT -i $ifaceInt -p tcp --syn -j syn-flood
iptables -A syn-flood -m limit --limit 1/s --limit-burst 4 -j RETURN
iptables -A syn-flood -j DROP
iptables -A FORWARD -p tcp --syn -m limit --limit 1/s -j ACCEPT
#Proteção contra falhas de segurança dos serviços do X Window
iptables -A INPUT -p tcp -s 0.0.0.0/0 -d 0.0.0.0/0 --dport 6000:6063 -j DROP
#Proteção contra port-scanners ocultos
iptables -A FORWARD -p tcp --tcp-flags SYN,ACK,FIN,RST RST -m limit --limit 1/s -j ACCEPT
iptables -N SCANNER
iptables -A SCANNER -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL FIN,URG,PSH -i $ifaceExt -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL NONE -i $ifaceExt -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL ALL -i $ifaceExt -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL FIN,SYN -i $ifaceExt -j DROP
iptables -A INPUT -p tcp --tcp-flags ALL SYN,RST,ACK,FIN,URG -i $ifaceExt -j DROP
iptables -A INPUT -p tcp --tcp-flags SYN,RST SYN,RST -i $ifaceExt -j DROP
iptables -A INPUT -p tcp --tcp-flags SYN,FIN SYN,FIN -i $ifaceExt -j DROP
iptables -A FORWARD --protocol tcp --tcp-flags ALL SYN,ACK -j DROP
#-m recent --update --hitcount=4 quer dizer se tentar passar pelo ip utilizando o nmap 4x será jogado na lista INVASOR
iptables -A INPUT -m recent --update --hitcount 4 --name INVASOR --seconds 3600 -j DROP
#indica bloqueio por 3600 segundos, ou seja, 1 hora o host que tentou realizar um scan na rede
iptables -A INPUT -m recent --set --name INVASOR
#Proteção contra IP Spoofing
iptables -A INPUT -s $LAN -i $ifaceExt -j DROP
for i in /proc/sys/net/ipv4/conf/*/rp_filter; do
echo 1 > $i
done
#Protecao contra ataques DoS
iptables -A INPUT -m state --state INVALID -j DROP
iptables -A OUTPUT -p tcp ! --tcp-flags SYN,RST,ACK SYN -m state --state NEW -j DROP
#Verifica pacotes fragmentados e os descarta
iptables -N VALID_CHECK
iptables -A VALID_CHECK -p tcp --tcp-flags ALL FIN,URG,PSH -j DROP
iptables -A VALID_CHECK -p tcp --tcp-flags ALL SYN,ACK,FIN,URG -j DROP
iptables -A VALID_CHECK -p tcp --tcp-flags ALL ALL -j DROP
iptables -A VALID_CHECK -p tcp --tcp-flags ALL FIN -j DROP
iptables -A VALID_CHECK -p tcp --tcp-flags SYN,RST SYN,RST -j DROP
iptables -A VALID_CHECK -p tcp --tcp-flags SYN,FIN SYN,FIN -j DROP
iptables -A VALID_CHECK -p tcp --tcp-flags ALL NONE -j DROP
#Bloqueia tudo que não foi especificado acima
iptables -A INPUT -p tcp --syn -j DROP
echo "Firewall ativo ---------------------------------[OK]"
}
stop(){
#Limpa as regras
iptables -F
iptables -X
iptables -Z
iptables -F INPUT
iptables -F OUTPUT
iptables -F FORWARD
iptables -t nat -F
iptables -t nat -X
iptables -t nat -Z
iptables -t mangle -F
iptables -t mangle -X
iptables -t mangle -Z
iptables -t raw -F
iptables -t raw -X
iptables -t raw -Z
#reseta as politicas padrões, aceita tudo
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
#compartilhamento de conexão
echo 1 > /proc/sys/net/ipv4/ip_forward
iptables -t nat -F POSTROUTING
iptables -t nat -A POSTROUTING -o $ifaceExt -j MASQUERADE
echo "Firewall desativado! -----------------------------[OK]"
}
case "$1" in
"start") start ;;
"stop") stop ;;
"restart") stop; start ;;
*)
echo "Use os paramentros: start|stop|restart"
esac




Fonte : http://mundodacomputacaointegral.blogspot.com.br/2012/05/entendendo-o-funcionamento-de-um.html