sexta-feira, 22 de outubro de 2010

Switch Dell 6024F - TRAPS e SNMP Query funcionar mutuamente

Perdi um bom tempo com o switch Dell 6024F, pois, o mesmo não aceitava as configurações de traps e snmp query para trabalharem mutuamente no switch, pesquisei muito na internet e não achei nada e por esse motivo posto aqui para quem estiver passando pela mesma situação. O problema foi que quando eu tentava configurar o switch, a partir da console WEB, para habilitar os serviços de TRAPS e SNMP o equipamento ficava bugado não funcionava de hipotese alguma essas funções mencionadas acima. O problema foi resolvido quando tentei configura-lo a partir da console CLI(Linha de Comando) do equipamento:
Habilite a SNMP Query através da CLI:

snmp-server community public ro 172.16.0.203 view default type router

Onde:
172.16.0.203 - é o computador que tem permissão para executar query na MIB do switch;

Depois é só habilitar pela console WEB o envio de TRAPS e agora o switch trabalhrá normalmente com ambos os serviços habilitados.

quinta-feira, 21 de outubro de 2010

IPFW - Balanceamento de tráfego com dois links WAN usando o IPFW - FreeBSD



#!/bin/sh

###########################################################################
# Delete todas as regras do IPFW, zera toda tabela de regras.
###########################################################################
/sbin/ipfw -f flush


###########################################################################
# Carregar duas instâncias do NATD, uma para cada interface WAN.
###########################################################################
/sbin/natd -u -dynamic -interface re0 -p 8668
/sbin/natd -u -dynamic -interface re1 -p 8669



###########################################################################
# Regra number 0001: De acordo com o pacote que estiver passando no momento pelo
# gateway, o IPFW primeiramente checará a tabela de sessão(que é criada
# dinamicamente se você adicionar o parâmetro keep-state na regra que queira
# torna-la dinâmica, veremos abaixo) dessa forma ele verifica se já não existe uma
# regra dinâmica que se aplique ao pacote passante, ou seja, aqui estamos utlizando
# o firewall no modo stateful.
###########################################################################
ipfw add 0001 check-state



###########################################################################
# Regra number 2000 e 2050: Definem as rotas para as intâncias do NATD
# criadas acima. Ou seja, aqui setamos para que ocorra NAT nos pacotes
# que passarem tanto pela interface re0 quanto pela interface re1.
###########################################################################
ipfw add 2000 divert 8668 ip from any to any in via re0
ipfw add 2050 divert 8669 ip from any to any in via re1



###########################################################################
# Regra number 2100: A palavra-chave desta regra é o cara que tem maior
# responsabilidade sobre todo o balanceamento de tráfego, este cara é o parâmetro
# prob, o seu valor varia de 0 a 1 e diz qual a probabilidade de executar tal regra.
# No caso da regra number 2100, informamos que 50%(0.5) do tráfego utilizando
# qualquer protocolo que seja IP(ip) de origem(from) 192.168.33.0/24 com destino(to)
# a qualquer lugar saindo (out) por alguma interface do gateway será pulada (skipto)
# para ser executada a partir da regra number 2200 em diante e além disso
# colocaremos esta regra na tabela de sessão com o parametro keep-state. Resumindo,
# estaremos colocando 50% do tráfego para ser roteado pelo NAT na interface re0 que
# corresponde a instância de porta 8668.
############################################################################
ipfw add 2100 prob 0.5 skipto 2200 ip from 192.168.33.0/24 to any out keep-state



###########################################################################
# Regra number 2150: Como 50% do tráfego será jogado para o NAT da interface re0, os
# outros 50% do tráfego será ignorado pela regra prob, e adivinha aonde o tráfego
# ignorado irá parar? Ele será executado pela regra number 2150, que diz que:
# Qualquer protocolo que seja IP(ip) de origem(from) 192.168.33.0/24 com destino(to)
# a qualquer lugar saindo (out) por alguma interface do gateway será pulada (skipto)
# para ser executada a partir da regra number 2300 em diante e além disso
# colocaremos esta regra na tabela de sessão com o parametro keep-state. Resumindo,
# estaremos colocando esse tráfego que não foi executado pela regra prob será
# roteado pelo NAT na interface re1 que corresponde a instância de porta
# 8669.
###########################################################################
ipfw add 2150 skipto 2300 ip from 192.168.33.0/24 to any out keep-state



############################################################################
# Regras utilizadas pelos skipto acima.
############################################################################
ipfw add 2200 divert 8668 ip from 192.168.33.0/24 to any in
ipfw add 2250 divert 8668 ip from 192.168.33.0/24 to any out
ipfw add 2300 divert 8669 ip from 192.168.33.0/24 to any out
ipfw add 2350 divert 8669 ip from 192.168.33.0/24 to any in

############################################################################
# Aqui eu encaminho(fwd) o tráfego que o gateway estar fazendo(192.168.1.222 e
# 192.168.4.222) para os gateways de rede 192.168.1.1 e 192.168.4.1.
############################################################################
ipfw add 2400 fwd 192.168.1.1 ip from 192.168.1.222 to any
ipfw add 2500 fwd 192.168.4.1 ip from 192.168.4.222 to any



############################################################################
# Aqui defina as regras allow e deny de seu firewall. Como este firewall é de
# teste estou permitindo todo tráfego de qualquer canto para qualquer canto
############################################################################
ipfw add 65000 allow ip from any to any

segunda-feira, 6 de setembro de 2010

VNC - Configurando o VNC no Linux como módulo do X11 no display 0

Foi utilizado para este artigo o S.O Red Hat Enterprise Linux ES release 4 (Nahant) e o vnc-server-4.0-8.1.

Se você precisar configurar o VNC para ser carregado na inicialização como módulo do X11 no display 0, ou seja, enxergar e acessar a sessão do usuário local para dar um suporte remotamente ao mesmo, ou seja, da mesma forma que acontece no winVNC da plataforma Windows que enxergamos a tela do usuário e os aplicativos que os estão sendo executados pelo mesmo.

Primordialmente instale o vnc-server no Linux, após isso iremos iniciar a configuração.

Procedimento para a configuração:

1 - Editar /etc/X11/xorg.conf:
# vi /etc/X11/xorg.conf


2 - Adicionar na seção "Module" a linha abaixo:
Load  "vnc"


3- Criar senha do acesso ao VNC A senha será gerada em um arquivo no home do usuário current(/home/usuario_current/.vnc/passwd) que estar a executar o comando abaixo, este arquivo deve ser apontado no arquivo xorg.conf como será explicado no passo 4:
Comando para criação do arquivo da senha:
# vncpasswd

Password:
Verify:
4 -Adicionar na seção "Screen" do aquivo xorg.conf
Section "Screen"
...

Option "SecurityTypes" "VncAuth" #Inserir esta linha no arquivo
Option "UserPasswdVerifier" "VncAuth" #Inserir esta linha no arquivo
Option "PasswordFile" "/root/.vnc/passwd" #Inserir esta linha no arquivo

...
EndSection

OBS.: Encontre no arquivo a sessão "Module", se não existir você deve inserir no final do arquivo fora de qualquer outra sessão, insira as seguintes informações:
Section "Module"
        Load  "dbe"
        Load  "extmod"
        Load  "fbdevhw"
        Load  "glx"
        Load  "record"
        Load  "freetype"
        Load  "type1"
        Load  "vnc"
        Load  "dri"
EndSection

Caso não deseje utilizar autenticação, adicionamos a linha abaixo dentro do arquivo xorg.conf ao invés de utilizar as linhas citadas acima:
Section "Screen"
...
Option "SecurityTypes" "None" #Inserir esta linha no arquivo
...
EndSection

5 - Restart o ambiente x11:
Para fazer isto sem a necessidade de restartar todo o servidor, podemos reiniciar somente o serviço x11, conforme abaixo:

Saia do modo gráfico colocando-o em modo CLI(Comand Line Interface, sem ambiente gráfico):
# init 3

Agora volte para o modo gráfico(KDE, Gnome etc):
# init 5

Pronto agora é só esperar o modo gráfico carrega assim como o serviço do VNC e depois testar a conexão com o server VNC.

quinta-feira, 26 de agosto de 2010

Nagios - Traps para o Nagios no FreeBSD

Para este artigo foi utilizado o S.O FreeBSD 8.0-RELEASE-p3 e os seguintes softwares:

- Nagios Core Version 3.2.0
- net-snmp-5.5_3
- snmptt_1.3
- Mibs dos switches Dell


Definições dos aplicativos utilizados:

Nagios:

Originalmente escrito sob o nome Netsaint, o Nagios1 foi criado e ainda
e mantido por Ethan Galstad e sua equipe de mais de 150 desenvolvedores
espalhados por todo o mundo, dedicados a desenvolver plugins, corrigir bugs,
desenvolver uma interface web, produzir e traduzir a vasta documentacao, entre
outras atividades. Este software de monitoramento de redes e distribuido
livremente, atraves da lei de copyleft GPL. A habilidade em administrar
ambientes com infra-estrutura de WAN, LAN e MAN, e a interface grafica – GUI
utilizada lhe garantem desempenho comparavel a sistemas comerciais existentes,
como WhatsUp e BigBrother, assim como o Angel Network Monitor, o PIKT, o
Autostatus e outros2.

FONTE: NAGIOS -mono-HettyAndrade.pdf - www.ginux.ufla.br/files/mono-HettyAndrade.pdf

http://www.nagios.org/

Net-SNMP :

Uma extensão da implementação SNMP, ele quem irá escutar os TRAPS enviados pelos dispositivos de rede para o servidor Nagios. Utiliza a porta padrão de TRAP UDP 162 para escutar as notificações TRAPS.

http://net-snmp.sourceforge.net/

SNMPTT :

SNMP Trap Translator é um manipulador de traps escrito em Perl para ser usado com o Net-SNMP / UCD-SNMP. Ele irá se integrar com o Net-Snmp para pegar os Traps que o este software capturou.

http://snmptt.sourceforge.net/

Mibs:

Será necessário baixar a MIB SNMP dos equipamentos de rede que você queira que o Nagios exiba no sistema. Pode ser inserido qualquer equipamento para enviar TRAPS para o Nagios bastando o mesmo possuir em sua MIB informações de suas TRAPS.


Vamos para a configuração:

1 – Com a MIB do seu equipamento em mãos iremos então converter para o formato exigido pelo SNMPTT. Podemos fazer isto manualmente, no README têm explicando como fazer, porém já deixo informado que é um pouco complexo construir este arquivo nas unhas, podemos fazer então com um script Shell que vêm no .tar do SNMPTT. O nome do script shell que vêm com o aplicativo SNMPTT é snmpttconvertmib, e para converter uma MIB para o formato do SNMPTT utilizamos a seguinte linha de comando:

/home/leonardo.conrado/snmptt/snmptt_1.3/snmpttconvertmib --in=/home/leonardo.conrado/switch-6024f.mib --out=/etc/snmptt.dell-6024f.conf --exec='/usr/local/libexec/nagios/eventhandlers/submit_check_result $r TRAP 1'


Onde, os parâmetros:

--in : a mib a qual deseje converter para a formato do SNMPTT.

--out : arquivo gerado pelo script SNMPTT, ele contém os TRAPS extraidos do arquivo .mib original e formatado para a compreensão do SNMPTT.

--exec : comando a ser executado quando chegar um Trap no net-snmp e capturado pelo SNMPTT se existir este Trap no aquivo do SNMPTT será executado este comando. Neste caso o comando colocará um status para o Nagios exibir nos problemas do serviços de rede, ou seja, este arquivo citado no --exec o "submit_check_result", este script irá escrever um comando para o arquivo de comando/status do Nagios, o nagios.cmd. Nota: Este script destina-se a ser executado no mesmo host que está executando o Nagios.

$r : Variavel contendo informações sobre o problema informado pelo TRAP enviado, isto será exibido no Nagios.

TRAP : Serviço configurado no Nagios(Iremos configurar este serviço para o Nagios, mais adiante).

1 : Uma das variáveis reservada do Nagios. Isso irá setar como será exibido no Nagios o problema do Trap.
STATE_OK=0
STATE_WARNING=1
STATE_CRITICAL=2
STATE_UNKNOWN=3
Se tiver muitos arquivos .mib para serem convertidos utilize este script .sh que cirei para converter os meus arquivos .mib de um equipamento:

!/bin/sh

for i in $( ls /home/leonardo.conrado/*.mib ); do
echo $i
/home/leonardo.conrado/snmptt/snmptt_1.3/snmpttconvertmib --in=$i --out=/etc/snmptt.mikrotik.conf --exec='/usr/local/libexec/nagios/eventhandlers/submit_check_result $r TRAP 1'
done


2 - Após converter os seus arquivos .mib vamos descompactar o .tar do aplicativo snmptt, e partirmos agora para a instalação do aplicativo snmptt para se integrar ao Nagios.

3 - Copie o arquivo snmptt para a pasta /usr/local/sbin (Lembrando que estamos configurando o snmptt no sistema FreeBSD), der permissão de execução para este arquivo(chmod +x snmptt);

4 - Copie o snmptt snmptthandler para a pasta /usr/local/sbin (Lembrando que estamos configurando o snmptt no sistema FreeBSD), der permissão de execução para este arquivo(chmod +x snmptthandler);

5 - Copie o arquivo snmptt.ini para /etc/, é neste arquivo que iremos indicar aonde estar o nosso arquivo .mib já convertido, para que a aplicação snmptt saiba as TRAPS
que deve registrar e enviar para o Nagios. No nosso caso devemos inserir no final deste arquivo snmptt.ini a linha: /etc/snmptt.dell-6024f.conf, conforme abaixo:

[TrapFiles]
# A list of snmptt.conf files (this is NOT the snmptrapd.conf file). The COMPLETE path
# and filename. Ex: '/etc/snmp/snmptt.conf'

6 - Crie a pasta /var/log/snmptt/ ;

7 - Edite /usr/local/etc/snmptrapd.conf e adicione a linha: traphandle default /usr/local/sbin/snmptthandler no topo do arquivo;

8 - Crie a pasta /var/spool/snmptt/

9 - Vamos colocar a aplicação para iniciar automaticamente no startup do servidor, para os sistemas Linux como: Mandrake, Red Hat e outros distros Linux o tar do snmptt já traz um script para ser colocado na pasta init.d, porém, como estamos instalando no FreeBSD teremos que criar o nosso próprio script ou consegui-lo através dos ports, bem eu decidi faze-lo mesmo:

10 - Então crie um arquivo chamado snmptt dentro da pasta /usr/local/etc/rc.d/ e der permissão executavel para o mesmo(chmod +x /usr/local/etc/rc.d/snmptt), vamos editá-lo:

[root@noc /usr/sbin]# vi /usr/local/etc/rc.d/snmptt


#!/bin/sh
# PROVIDE: snmptt
# REQUIRE: DAEMON
# BY LEONARDO COUTO CONRADO
. /etc/rc.subr

name="snmptt"

rcvar="`set_rcvar`"

load_rc_config $name

: ${snmptt_enable="YES"}

command="/usr/local/sbin/${name}"
command_args="--daemon"
procname=/usr/bin/perl
pidfile="/var/run/${name}.pid"

run_rc_command "$1"


11 - Edite também o arquivo /etc/rc.conf e adicione a seguinte linha: snmptt_enable="YES"

12 - Aproveitando a edição do arquivo /etc/rc.conf coloque ou modifique as linhas referentes aos serviços que trabalham junto com o snmptt, são eles o snmptrapd(Responsável por escutar as TRAPS enviadas pelos seus equipamentos de rede) e o serviço snmp. O arquivo que estar em produção aqui estar dessa forma:

#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
# Enable of SNMP - Simple Network Management Protocol
#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
snmpd_enable="YES"
snmpd_flags="-a"
snmpd_conffile="/usr/local/share/snmp/snmpd.conf"

#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
# Enable of snmptrapd_enable for traps
#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
snmptrapd_enable="YES"
snmptrapd_flags="-a -On -Lsd -p /var/run/snmptrapd.pid -c /usr/local/etc/snmptrapd.conf"

#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
# Enable of snmptt_enable for NAGIOS to receiver traps of equipaments of the network
#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
snmptt_enable="YES"

13 - Você pode também iniciar a aplicação para testa-la, para debug, com o comando:

snmptt --daemon


Para debugar possiveis erros visualize o seu /var/log/messages e também utilize o comando ps auxww | grep snmptt, abaixo mostro que os processos estão rodando de forma correta:

[root@noc /etc]# ps auxww | grep snmptt
root 886 0.0 0.4 23124 2244 ?? Ss 14Sep10 1:27.46 /usr/bin/perl /usr/local/sbin/snmptt --daemon (perl5.8.9)
root 887 0.0 0.7 23124 3448 ?? Ss 14Sep10 5:01.94 /usr/bin/perl /usr/local/sbin/snmptt --daemon (perl5.8.9)
root 25856 0.0 0.2 8060 1108 0 S+ 4:34PM 0:00.01 grep snmptt


Vejam que ele inicia duas instâncias do snmptt.

14 - Um possível erro que pode ocorrer durante o startup do daemon snmptt estar relacionado a alguns módulos do perl estarem faltando ou alguns INIFiles. Comigo o erro que aconteceu foi o seguinte abaixo:

9.4. I see following error: Can't locate Config/IniFiles.pm in @INC ...What should I do?

It's likely that you don't have required Perl modules installed. In this case it's Config::IniFiles that is missing. The easiest way to install Perl modules is to use CPAN extension, eg. perl -MCPAN -e 'install Config::IniFiles'.

Para resolver este caso execute a instalação dos INIFiles conforme mostro abaixo:

perl -MCPAN -e 'install Config::IniFiles'


Bem agora iremos para a parte de integração com o Nagios:

1 - Baixe o .tar do Nagios, aqui utilizei o nagios-3.2.0.tar.gz

tar -xzf nagios-3.2.0.tar.gz


2 - Iremos copíar o script submit_check_result da pasta descompactada do Nagios para a pasta /usr/local/libexec/nagios/eventhandlers/, este script é o responsável por pegar a TRAP e colocar no arquivo nagios.cmd que é o arquivo que coloca todos os eventos/status dos equipamentos em fila para que seja exibido no Nagios. Na verdade quem captura a TRAP é daemon snmptrapd ele fica escutando as TRAPS na porta UDP 161 do seu servidor Nagios e então captura qualquer TRAP que for enviada para o seu servidor, quando a trap é capturada o daemon do snmptt pega essas informações registradas pelo snmptrapd e então verifica no arquivo de mib convertido para ver se encontra algum OID com o mesmo valor do OID do TRAP recebido, se encontrar então ele executa o parametro EXEC referente ao OID encontrado, exemplo na prática:

1 - Um cooler do Switch dell 6024F, que estar configurado para enviar TRAPS para o servidor Nagios, parou, nesse momento o switch envia um pacote TRAP com OID .1.3.6.1.4.1.674.10895.3000.2.1.0.1 para o servidor Nagios.

2 - O daemon snmptrapd que estar escutando na porta UDP 161 captura este pacote e registra em seu log;

3 - O daemon snmptt sabendo desse recebimento de TRAP irá verificar para ver se o OID do TRAP recebido é igual algum OID que estar naquele arquivo convertido a partir de algum arquivo .mib, lembra? Nesse caso que estamos descrevendo, houve a conversão de diversos arquivos .mib baixados no site da Dell referentes a seus switches de série 6020F e convertidos para o padrão exigido do snmptt.

4 - Se houver o OID no arquivo .mib convertido ,então, o daemon do snmptt irá para o próximo passo que é executar o EXEC referente a esse OID, no caso como foi um cooler do switch que parou ele dispara o EXEC do OID .1.3.6.1.4.1.674.10895.3000.2.1.0.1, este OID é o que mostro abaixo:

EXEC /usr/local/libexec/nagios/eventhandlers/submit_check_result $r TRAP 2 "Product Global Status Change.: The product global status has changed from $2 to $1 at time $3."

Este EXEC executa o script do Nagios o submit_check_result passando parametros que são as informações necessárias para exibir o status do equipamento no Nagios.

DETALHE! ATENÇÂO!
Devemos fazer uma modificação no script submit_check_result, já que estamos configurando para o FreeBSD, o detalhe estar na variável CommandFile do script esta variável aponta o arquivo nagios.cmd do Nagios, que por sinal fica em um local diferente das instalações realizadas em distros Linux. Você deve trocar:

De:

CommandFile="/usr/local/nagios/var/rw/nagios.cmd"

Para:

CommandFile="/var/spool/nagios/rw/nagios.cmd"


Bom o que devemos fazer agora é a configuração nos arquivos .cfg do Nagios:

1 - Configurar um template para o serviço TRAP, então:

vi /usr/local/etc/nagios/objects/templates.cfg


Adicione as linhas abaixo:

############################################################################################
# CREATED FOR THE TRAP SERVICE
############################################################################################
# MODELO 01:
#######################################################################
define service{
name generic-trap-service
register 0
is_volatile 1
check_period 24x7
max_check_attempts 1
normal_check_interval 1
retry_check_interval 1
active_checks_enabled 0
passive_checks_enabled 1
retain_status_information 1
retain_nonstatus_information 1
notification_interval 31536000
notification_period 24x7
notification_options w,u,c
notifications_enabled 1
check_freshness 1 Enable freshness checking
freshness_threshold 360 Reset trap alert every 6 min
contact_groups admins
}


2 - Como estamos monitorando TRAPS vindos de switches irei adicionar mais um serviço para os switches

vi /usr/local/etc/nagios/objects/servicesswitch.cfg


Adiciona para cada switch da minha rede mais um serviço a ser monitorado, o do TRAP:

# Define a service TRAP for switch/equipament
define service{
use generic-trap-service
host_name SWHCDB13448P
service_description TRAP
check_command check-host-alive
}


OK, após estas configurações iremos dar um reload no Nagios para ele recarregar as configurações:

[root@noc /usr/local/etc/nagios/objects]# /usr/local/etc/rc.d/nagios reload


Pronto, é isso, com este procedimento deveremos ter o Nagios recebendo os TRAPS dos equipamentos habilitados para enviar TRAP para o servidor Nagios.

quarta-feira, 7 de julho de 2010

IPFW - Criação de regras no IPFIREWALL

Para este artigo foi utilizado o FreeBSD 7.2 e o IPFW2.

Se o seu servidor FreeBSD ainda não tem o IPFW compilado no kernel, então acesse o link abaixo e veja como configura-lo e instala-lo em seu kernel:


Inicialmente é bom informar as duas formas de funcionamento do firewall IPFW, no que diz respeito ao tratamento que é dado aos pacotes que trafegam por ele.

Os modos em que o IPFIREWALL pode funcionar são:

Modo Filtro de pacotes:

- Restringir o tráfego baseado no endereço IP de origem ou destino, através das portas de comunicação TCP ou UDP.


Modo Firewall stateful:

- Herda as característica do firewall em modo filtro de pacotes e implementa o filtro por estado da sessão; Nesse caso o firewall armazena os estados das conexões e aplica o filtro de bloqueio ou permissão para o pacote passante com base nesses estados. O firewall armazena em uma tabela os detalhes das conexões existentes (IP de origem, IP de destino, porta de origem, porta de destino, tempo restante para essa conexão na tabela stateful)  que estão sendo efetuadas no momento e inspeciona o tráfego evitando que pacotes ilegítimos tenham acesso a serviços de rede ganhando mais velocidade e segurança, evitando, por exemplo, técnicas hacker como: ip spoofing.

Construção do conjunto de regras(Ruleset):

Primeiramente será apresentado o conjunto de regras que são pré-definidas para o IPFW, essas são regras que já vem prontas para serem utlizadas no Firewall.

Ruleset pré-definidas:

A variável do /etc/rc.conf que gerencia qual o conjunto de regras pré-definidas será carregada pelo firewall é a firewall_type=" " . Exitem 5 tipos de regras pré-definidas disponíveis:

"OPEN" -  O firewall permiti todo tráfego em suas interfaces, ou seja, não bloqueia nenhuma tráfego.

"CLIENT" - Essa definição de tipo de firewall (firewall_type) permite todo o tráfego proveniente da rede local (por exemplo, uma rede interna atrás de NAT) pra ela mesma. Bloqueia pacotes fragmentados, permite que mensagens de email, resoluções de nomes (DNS) e NTP sejam enviadas pra dentro e fora da rede, e não permite nenhuma máquina que esteja fora da rede interna iniciar conexões TCP com máquinas dentro da rede. Se a rede estiver por trás de uma implementação básica de NAT sem nenhuma opção de proxie carregada isso já seria impossível. Esse tipo de firewall funciona com política aberta ou fechada, definida no kernel, ou seja, não faz diferença se você colocou IPFIREWALL_DEFAULT_TO_ACCEPT ou IPFIREWALL_DEFAULT_TO_DENY como padrão.

"SIMPLE" - Esse tipo de firewall é uma contradição. Apesar do nome SIMPLE, ele é muito mais complexo que a definição CLIENT, e requer que o usuário tenha algum conhecimento nos padrões RFC de Internet pra poder entender suas definições de regras de firewall. Essa regra vai evitar spoofing (técnica onde uma máquina se faz passar por outra, alterando seu endereçamento IP) não permitindo a entrada de nenhum pacote que tenha um endereço de retorno igual ao endereço de qualquer host dentro da rede interna. Vai bloquear todos os pacotes endereçados como de redes privadas, conforme definido na RFC 1928, evitando o tráfego pra dentro ou fora da rede, e vai bloquear ainda todas as redes não-roteaveis, conforme definido no Internet-Drafts da IETF (disponível em http://www.ietf.org/internet-drafts/draft-manning-dsua-03.txt). Esse tipo de firewall vai permitir tráfego de e-mail, de WWW, de DNS, e NTP, e vai permitir também pacotes fragmentados, e em relação às conexões TCP iniciadas por hosts fora da rede, o firewall não vai apenas bloquear, como na definição CLIENT, vai também logar todas essas tentativas.

"CLOSED" - Tecnicamente essa definição não é um conjunto de regras de firewall, porque não adiciona nenhuma regra. Na verdade, aqui acontece tudo que nós insistimos que você deve evitar, ou seja, estabelece uma política fechada, negando todo e qualquer tráfego da rede (exceto o tráfego via lo0 que nós vimos anteriormente que é controlado por padrão). Essa definição simplesmente desabilita todos os serviços IP na rede, a não ser que no seu kernel você tenha adicionado a regra de política aberta. Então, ajustar o firewall pra CLOSED vai ser necessário em casos *extremos* onde você prefere (ainda que temporariamente) tirar toda a sua rede de funcionamento. Ou seja, não defina como padrão no rc.conf.

"UNKNOWN" - Desabilita o carregamento de regras do ipfirewall.

Agora iremos abordar a construção do conjuto de regras personalizaveis para o IPFW utilizaremos neste momento o modo filtro de pacotes. Para isso é necessário criar um arquivo onde será colocado as nossas regras, que será onde o IPFW irá ler as mesmas. Para isso iremos criar o arquivo de regras, como mostra abaixo:

# mkdir -p /tools/firewall

# touch /tools/firewall/rules.fw

Iremos editar o arquivo rules.fw:
# vi /tools/firewall/rules.fw

Agora iremos começar a escrever as nossas regras, mas como é a sintaxe para se escrever as regras no IPFIREWALL?
Abaixo uma breve explicação sobre a sintaxe das regras do IPFW:
CMD [número_regra] [prob probalilidade] ação [log [logamount número] ] corpo_regra

CMD =
add, delete(Os mais utilizados)


add: adicionar uma nova regra ao firewall;
delete: deletar uma regra do firewall;

[número_regra]
=
Quando um pacote entra no firewall ele é comparado com a primeira regra no conjunto de regras e avança uma regra de cada vez, que se deslocam de cima para baixo do conjunto em ordem crescente do número de seqüência das regras. Quando o pacote se adequa a seleção de parâmetros de uma regra, o campo de ação é executada e a busca do conjunto de regras termina para o pacote. Isto é referido como "o primeiro que se adequa ganha" do metodo de procura. Se o pacote não corresponde a nenhuma das regras, ele é pego pela regra padrão obrigatório IPFW, número 65.535, que nega todos os pacotes e descarta-los sem qualquer resposta de volta para o remetente, a não ser que se coloque na regra para que o IPFW envie uma mensagem de resposta.
O número de regras varia de 1 a 65535 e indica a sequência em que as regras serão processadas, sendo que a regra de número 65535 é a padrão utilizada pelo firewall, ou seja exclusiva do firewall, essa regra padrão pode ser aceitar tudo(tcp, udp e ip) de qualquer lugar para qualquer lugar ou negar tudo(todos os protocolos tcp, udp e ip) de qualquer lugar para qualquer lugar. Essa regra é especificada antes da compilação do firewall é uma linha que você especifica no kernel IPFIREWALL_DEFAULT_TO_ACCEPT ou IPFIREWALL_DEFAULT_TO_DENY.


[prob probabilidade]
=
Uso opcional, Define uma probabilidade para aplicar a regra. Varia de 0 a 1.

ação =
"allow, accept, pass e permit"
Tem a mesma função, aceitar pacote que chegam ao firewall e que se adequem a regra. E a leitura das regras termina.

"deny, drop
"
Tem a mesmo função, descartar pacotes silenciosamente(sem enviar resposta ao remetente) que correspondem a regra. E a leitura das regras termina.

"check-state"- Checa o pacote contra um conjunto de regras dinâmicas, isto é para modo statefull do firewall que ainda iremos ver.

"count" - Todos os pacotes que combinarem com uma regra cuja ação seja "count", determinará que o ipfirewall incremente o contagem de pacotes, ou seja, a saída de "ipfw show" indicará mais uma ocorrência de pacotes nessa regra. Motivos estatísticos óbvios. O processamento das regras do firewall continuam a buscar por outras regras que combinem com os pacotes.

"divert porta" - Redireciona o pacote para a porta especificada, utilizando um socket "divert". Pode ser especificado número ou nome, veja /etc/services.

"fwd ip[,porta]" - Sinônimo de forward, encaminha o pacote para o ip especificado. Se o ip for local será encaminhado para a porta especificada, se o ip não for local a porta será ignorada. O pacote não é alterado, e isto inclui o ip de destino, então se o pacote for encaminhado para outro host provavelmente será rejeitado. Caso seja encaminhado para um ip local, desta máquina, o socket que irá receber o pacote terá o seu endereço alterado para coincidir com o endereço de destino do pacote, aceitando desta forma o mesmo.

"pipe número" - Passa o pacote através de um "pipe" dummynet, para controle de tráfego.

"queue número" - Passa o pacote para uma "queue" dummynet, para controle de tráfego utilizando WF2Q+.

"reset" - Quando um pacote encontra uma regra com essa ação, o pacote é bloqueado, e o ipfirewall tenta enviar um sinal (flag) de TCP Reset (RST) pro endereço de origem do pacote. O processamento das regras pra esse pacote termina. Como esse tipo de regra apenas se aplica pra pacotes TCP, o protocolo especificado na regra deve ser "tcp", para que apenas tais pacotes sejam processados por essa regra, e não todos (proto "all") os protocolos de pacotes IP.

"skipto " - Todos os pacotes que combinem com uma regra cuja ação seja "skipto " vão fazer com que o ipfirewall(4) continue processando esse pacote e buscando ocorrência nas regras que sejam de ordem maior ou igual ao indicado pela ação.

"reject" - Essa ação é pouco utilizada atualmente. Quando um pacote combina com uma regra cuja ação seja "reject", então o ipfirewall(4) bloqueia esse pacote e responde com uma mensagem ICMP do tipo "host unreachable", dando a impressão que a máquina se encontra fora da rede. Essa é uma forma não silenciosa de negar o tráfego pelo firewall, contudo, assim como a ação "reset", essa ação também aumenta o uso da sua banda de rede.

"tee porta" - Aceita o pacote e envia uma cópia do mesmo para a porta especificada, via socket "divert".

"unreach código" - Descarta o pacote, e tenta enviar uma resposta "ICMP unreachable" com o código especificado. O código deve ser entre 0 e 255, ou alguma destas palavras chave: net, host, protocol, port, needfrag, srcfail, net-unknown, host-unknown, isolated, net-prohib, host-prohib, tosnet, toshost, filter-prohib, host-precedence ou precedence-cutoff.

[log [logamount número]] =
Uso opcional, caso mencionada a palavra log, cada vez que um pacote coincidir com esta regra será feito um log através do syslog.

corpo_regra =
Contém uma ou mais exigências que o pacote precisa coincidir para a regra ser atendida. Essa especificação pode incluir endereço ip de origem, endereço ip de destino, porta de origem, porta de destino, protocolo, interface de rede de entrada, interface de rede de saída etc. O corpo da regra pode possuir uma ou mais opções. Essas opções podem ser precedidas de "not", como negação, ou serem agrupadas em blocos OR, entre chaves, por exemplo: { dst-port 50 or dst-port 51 or not src-port 52 }. Descreveremos cada uma dela abaixo:

"dst-ip endereço" - Endereço IP de destino do pacote.
"dst-port porta" - Porta(s) de destino do pacote. Se for especificada mais de uma porta, separar por vírgula (50, 51, 52), ou em faixa de portas (50-60).
"established"
Se o pacote tiver os bits RST ou ACK.
"frag"
fragmentos de pacotes, não sendo o primeiro fragmento.
"gid grupo"
Pacotes TCP ou UDP enviados ou recebidos pelo grupo. O grupo pode ser especificado pelo nome ou pelo GID.
"icmptypes tipo"
Tipo(s) de pacotes ICMP. Se for mais de um, separar por vírgula. Os tipos podem ser: echo reply (0), destination unreachable (3), source quench (4), redirect (5), echo request (8), router advertisement (9), router solicitation (10), time-to-live exceeded (11), IP header bad (12), timestamp request (13), timestamp reply (14), information request (15), information reply (16), address mask request (17) e address mask reply (18).
"in | out"
Pacotes de entrada ou de saída. Note que isto significa que os pacotes estão entrando ou saindo da máquina, então mesmo que um pacote venha da rede interna, estará entrando na máquina antes de sair.
"keep-state"
Quando um pacote coincidir com uma regra que tiver esta opção, será criada uma regra dinâmica, cujo comportamento será coincidir o tráfego bidirecional entre este ip/porta de origem e ip/porta de destino, no mesmo protocolo. A regra dinâmica expira após um certo tempo. Dessa forma, pode-se definir uma regra "check-state" anterior a esta, liberando este fluxo de pacotes, e teremos um firewall "stateful".
"limit {ip-origem | porta-origem | ip-destino | porta-destino} número"
Serão permitidas apenas o número especificado de conexões com os parâmetros especificados.
"mac mac-destino mac-origem"
Pacotes com o endereço MAC de destino e/ou de origem especificados. Se não for especificado algum deverá ser usada a palavra "any", para coincidir com todos os endereços.
"proto protocolo"
Pacotes com o protocolo (IP) especificado. Veja /etc/protocols.
"recv interface | xmit interface | via interface"
Pacotes recebidos pela interface de rede especificada (recv xl0), pacotes transmitidos pela interface especificada (xmit fxp0), ou pacotes passando pela interface, independentemente de entrar ou sair (via xl0). Quando xmit for utilizado é requerida a opção "out", já que o pacote estará saindo.
"setup"
Pacotes com o bit SYN mas sem o bit ACK.
"src-ip endereço"
Endereço IP de origem do pacote.
"src-port porta"
Porta(s) de origem do pacote.
"tcpflags flags"
Flags dos pacotes TCP, separadas por vírgula. As possíveis são: fin, syn, rst, psh, ack e urg. A negação pode ser feita por um "!".
"uid usuário"
Pacotes TCP ou UDP enviados ou recebidos pelo usuário. O usuário pode ser especificado pelo username ou pelo UID.
"vrrevpath"
Pra pacotes de entrada, é feita uma consulta ao endereço de origem na tabela de roteamento. Se a interface na qual o pacote entrou é a mesma de saída especificada pela rota, então a regra coincide. Isto pode ser utilizado para criar regras anti-spoofing. Os pacotes de saída não são submetidos à verificação.
PARA UMA LEITURA MAIS AVANÇADA ACESSE OS FONTES DO TEXTO ACIMA:
http://www.freebsd-howto.com/HOWTO/Ipfw-HOWTO

http://www2.unijui.tche.br/~heini/freebsd/ipfw2.html

Exemplos práticos:
### Liebrar udp da rede 192.168.0.0/24  para a rede 192.168.1.0/24
add 00100 allow udp from 192.168.0.0/24 to 192.168.1.0/24 in
### Regra para o INPUT do trafego SSH
add 00200 allow tcp from any to 192.168.1.1/32 22 in
### Regras para o INPUT do VNC da rede 192.168.1.0/24 para VNCs na rede 192.168.1.0/24
add 00300 allow tcp from 192.168.1.0/24 to 192.168.0.0/24 5900 in setup
### Bloquear todos os pacotes vindo de qualquer lugar para qualquer lugar e logar os mesmo
add 64534 deny log all from any to any
Resumindo a sintaxe das regras no IPFW:

# O comando entre colchetes é opcional
command   [rule number]   action   proto   from   source[port]   to   destination[port] [Complemento: in,out,via... etc]

Seguidores