quinta-feira, 11 de novembro de 2010

Baixe já a sua Linux Magazine Community Edition 72


Aí Galera irei começar a disponibilizar aqui no blog link para download da revista Linux Magazine as edições oferecidas para a comunidade Linux quando a mesma for liberada.

Já está no ar a Linux Magazine 72 Community Edition. Confira nesta edição os principais assuntos da Linux Magazine de novembro (Descomplicamos o VoIP) e leia um artigo completo sobre autenticação de usuários com PAM, e uma análise sobre TeamViewer, ferramenta para controle remoto gráfico.

Abaixo segue link da edição 72 oferecida para a community:


quarta-feira, 10 de novembro de 2010

Shell scripting

Shell script

Shell script é uma linguagem de script usada em vários sistemas operacionais derivados do UNIX. O shell script é batizado com este nome devido a ele ser um arquivo em texto plano, ou seja, legível para uma pessoa interpretar as sua linhas de comandos que segue a forma de um script, ou seja, intruções são executadas passo à passo além disso este arquivo é colocado como um tipo de arquivo executável, e o Shell é o interpretador de comandos dos sistemas Unix-Like. O shell é aquele que aparece logo após digitar-se a senha do usuário e entrar na famosa tela preta que espera ansiosamente por algum comando para ele poder executar. Essa é a sua função: esperar e executar. Cada comando digitado é lido, verificado, interpretado e enviado ao sistema operacional para ser de fato executado. Um exemplo de interpretador de comandos é o bash, usado na grande maioria das distribuições GNU/Linux. O shell é a ligação entre o usuário e o kernel. O kernel é quem acessa os equipamentos(hardware) da máquina, como disco rígido, placa de vídeo e modem.

A maior parte dos usuários classificam shell script como uma linguagem de fácil aprendizado. O primeiro passo é saber o que se deseja fazer, então, ver qual o código que executa este comando em shell e aí criar, basta escrever o código em algum editor de texto e salvar. Depois de salvo você deve coloca-lo como arquivo executável fazendo desta forma:

chmod +x "Nome do arquivo, sem aspas"

Depois de coloca-lo como executável, executamos o arquivo, dessa forma:

./"Nome do arquivo, sem aspas"

Para exibir um manual do bash ou mesmo do comando 'chmod', digite na linha de comando
man bash
ou
man chmod


É possível executar o arquivo mesmo sem modificar a permissão de execução, por exemplo, se for um arquivo escrito para ser executado pelo bash, usar:


sh ./"Nome do arquivo, sem aspas"

FONTE: http://pt.wikipedia.org/wiki/Shell_script


Abaixo temos alguns links para o download de livros sobre shell scripting que serão bastante úteis para aqueles que querem aprender ou aprimorar o seu conhecimento sobre shell script:

- http://tips-linux.net/en/content/pro-bash-programming
- http://tips-linux.net/en/content/expert-shell-scripting
- http://tips-linux.net/en/content/beginning-linux-command-line
- http://tips-linux.net/en/content/bash-pocket-reference
- http://tips-linux.net/en/content/linux-command-line-and-shell-scripting-bible

Agradecimento ao tips-linux.net : Compartilhando conhecimento; Neste site você encontrará dicas, e-books, tutoriais, Linux Commands, Softwares, Drivers e muito mais spbre o mundo Linux.

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]

segunda-feira, 28 de junho de 2010

Snorby - Instalação do frontend para snort

Utilizei para esta implementação o snorby 1.1.3 , ambos sobre o FreeBSD 7.2, mais detalhes sobre essa aplicação:

- Snorby 1.1.3:

O snorby é um dos frontends utilizados para visualizar os alertas gerados pelo snort, ele também contém gráficos e estatisticas dos alertas coletados pelo snort. Possui uma interface bastante intuitiva e moderna. Conheça-o http://snorby.org/.

Particulamente gostei muito deste frontend, ele ainda esta em fase de desenvolvimento, mas já dar para utiliza-lo em produção. Veja o report bug do mesmo com a identificação de erros e suas devidas correções e ferramentas a serem implementadas: http://github.com/mephux/Snorby/issues.

O Snorby é desenvolvido utilizando a linguagem de programação ruby on rails para plataforma web. Outro ótimo frontend é o BASE(http://base.secureideas.net/) fork do antigo ACID ambos são desenvolvidos utilizando a ligaugem de programação php.

Vamos para a instalação:

- Programas/dependênias para instalação do Snorby(Instalaremos através do ports):

git-1.7.1 Distributed source code management tool
mysql-client-5.5.4 Multithreaded SQL database (client)
mysql-server-5.5.4 Multithreaded SQL database (server)
ruby18-gems-1.3.7 Package management framework for the Ruby language
ruby18-iconv-1.8.7.248,1 An iconv wrapper class for Ruby

- E através do gem(Gerenciador de pacote do ruby) instalaremos outros pacotes:

- prawn
- rake
- rails
- dbd-mysql
- mysql

- E finalmente através do git:

- Snorby

- Vamos a instalação dos programas e dependencias(No configure do make não marque as opções que aparecerão desmarcadas e deixe as que já estão marcadas):

Instalação do mysql:

# cd /usr/ports/databases/mysql55-server/ && make install clean

Instalação do git:

# cd /usr/ports/devel/git/ && make install clean

Instalação do ruby-gems:

# cd /usr/ports/devel/ruby-gems/ && make install clean

Instalação do ruby-iconv:

# cd /usr/ports/converters/ruby-iconv/ && make install clean

- Instalação dos pacotes através do gem:

# gem install prawn


# gem install rake


# gem install rails


# gem install dbd-mysql


# gem install mysql

Vamos instalar o aplicativo Snorby, instale o mesmo na pasta /usr/local/www então siga o passo a passo:
OBS.: O git utiliza uma porta especifica para realizar o download verifique o seu firewall.

# cd /usr/local/www/ && git clone git://github.com/mephux/Snorby.git

Pronto se tudo ocorreu sem problemas o servidor já se encontra com o snorby instalado, iremos para os pré-requisitos de seu funcionamento:

- Primeiro: Configure o seu snort com banco mysql.

- Segundo: O snorby terá um banco, criado automaticamente pelo rake setup(comando que veremos mais adiante);

- Terceiro : O mysql deve estar iniciado e com permissões de acesso para usuário e seu banco de dados snorby, pois, agora será utilizado somente um único banco que armazenará informações tanto do snort quanto do snorby.

- Quarto: O banco snorby/snort é criado automaticamente pelo rake setup(comando que veremos mais adiante) no localhost ou seja na máquina em que foi instalado o snorby. Não consegui descobri onde alterar essa config.

OBS.: Der permissão para o usuário do banco snorny, para o host localhost, exemplo:

na console do mysql:

GRANT ALL PRIVILEGES ON snorby.* TO snorby@'localhost' IDENTIFIED BY 'senhaDoBDSnorby' WITH GRANT OPTION;

- Após estes passos iremos configurar dois arquivos do Snorby que se encontram em /usr/local/www/Snorby/config, são eles o database.yml e email.yml;

# cp /usr/local/www/Snorby/config/database.yml.example /usr/local/www/Snorby/config/database.yml


# cp /usr/local/www/Snorby/config/email.yml.example /usr/local/www/Snorby/config/email.yml

- Configure os mesmos, o database.yml configura aonde será instalado o banco de dados do snorby e o email.yml confgs para enviar alertas para o email.

Vamos ao processo de confguração automatica do Snorby(Instale os requerimentos adicionais do gem, ele irá informa na console quais são os requerimentos, para carregar o Snorby)

ATENÇÂO: Nessa versão do snoby(1.1.3) a instalação automática só é executada com sucesso se for configurado no arquivo database.yml o BD como localhost e dada as devidas permissões para o usuário que você passa neste mesmo arquivo citado. Aqui onde trabalho configurei como localhost depois instalei o snprby e após instalação executei o script mysql do snorby em outro servidor mysql da minha rede e depois fiz os devidos apontamentos database.yml para o servidor mysql remoto da minha rede.

# cd /usr/local/www/Snorby && rake gems:install


# cd /usr/local/www/Snorby && rake snorby:setup RAILS_ENV=production

Se for a primeira instalação execute também:

# cd /usr/local/www/Snorby && rake snorby:update RAILS_ENV=production


# cd /usr/local/www/Snorby && rake snorby:reset RAILS_ENV=production # ALL DATA WILL BE LOST

Start Snorby:

# ruby18 script/server -e production -b 127.0.0.1 -p 80 -d

-b = bind address [Default: loopback]
-p = port number [Default: 3000]
-e = environment
-d = Run server as daemon

The default User Name and Password for Snorby:

User: snorby
Password: admin

FONTE:

http://github.com/mephux/Snorby

http://wiki.github.com/mephux/Snorby/snorby-recipe-with-barnyard2-unified2-and-apache-jjc


Fiz um script para colocar na inicialização do sistema operacional o snorby, como é FreeBSD este script deve ser colocado em /usr/local/etc/rc.d/:

#!/bin/sh
#
# $FreeBSD: snorby
#

# PROVIDE: snorby
# BY: Leonardo Couto Conrado
# IN: 11.06.2010

. /etc/rc.subr

name="snorby"

rcvar="`set_rcvar`"

load_rc_config $name

: ${snorby_enable="NO"}
: ${snorby_port_listen="80"}
: ${snorby_bind_addr="127.0.0.1"}
: ${snorby_environment="production"}


command="cd /usr/local/www/Snorby && /usr/local/bin/ruby18"
command_args="script/server -e ${snorby_environment} -b ${snorby_bind_addr} -p ${snorby_port_listen} -d"
procname="/usr/local/bin/ruby18"
pidfile="/var/run/${name}.pid"

run_rc_command "$1"

E no /etc/rc.conf colocamos as seguintes linhas:

#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
# SNORBY
#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
snorby_enable="YES"
snorby_port_listen="80"
snorby_bind_addr="127.0.0.1"
snorby_environment="production"

Pronto agora já temos o snorby instalado e na inicialização do SO.

segunda-feira, 21 de junho de 2010

Snort - Instalação

Utilizei para esta implementação o snort 2.8.6 , ambos sobre o FreeBSD 7.2, mais detalhes sobre essa aplicação:

- Snort 2.8.6:

http://conteudoopensource.blogspot.com/2010/06/snort-snort-286-em-modo-promiuscuo.html

O snort pode ser utilizado tanto para detectar ataques(IDS colocando-o em modo promiscuo utilizando por exemplo o port mirror no switch) quanto também para detectar e bloquear os ataques(IPS colocando-o no modo in-line no gateway, firewall de sua rede.), neste tutorial estou utilizando o snort em modo promiscuo realizei um port mirror da porta dos gateways da rede e os alertas estão sendo registrados em um banco mysql.

Bem, vamos dar o start-up em nosso assunto principal que é a instalação do snort:

OBS.: Para utilizar o output(alertas e logs) direcionado para banco de dados mysql, vc antes deverá instalar o mysql e suas bibliotecas.

1) Baixe o snort http://www.snort.org/downloads. Descompacte o tallbar(arquivo tar.gz) do snort;

2) Dentro da pasta descompactada, iremos iniciar a configuração, compilção e instalação:

-> Configure com output para DB mysql:


#./configure --with-mysql --with-mysql-includes=/usr/local/include/mysql --with-mysql-libraries=/usr/local/lib/mysql --prefix=/usr/local/snort


# make


# make install


3) Criar estruturas de diretórios do snort

# mkdir /usr/local/etc/snort

Na pasta descompactada do snort, copie os arquivos do diretório conforme abaixo:

# cp /home/leonardo.conrado/snort-2.8.6/etc/* /usr/local/etc/snort/


4) Copiar as rules que deve ser baixados do site snort.org(Vc deve se cadastrar antes) e coloque-as em /usr/local/snort/rules(crie a pasta rules se não existir)

# cp /home/leonardo.conrado/snortrules-snapshot-2860/* /usr/local/snort/rules

5) Configurar o snort, conforme abaixo:

# vi /usr/local/etc/snort/snort.conf

Configure as principais variáveis, veja os exemplos já configurado:

###################################################
# Step #1: Set the network variables. For more information, see README.variables
###################################################
# Setup the network addresses you are protecting
var HOME_NET [192.168.1.0/24]

# List of DNS servers on your network
var DNS_SERVERS [192.168.0.60/32,187.84.92.1,187.84.92.2/32]

# List of web servers on your network
var HTTP_SERVERS [192.168.0.64/32]

# List of sql servers on your network
var SQL_SERVERS [192.168.0.65/32]

# List of SMTP servers on your network
var SMTP_SERVERS 187.84.92.99

# Path to your rules files (this can be a relative path)
# Note for Windows users: You are advised to make this an absolute path,
# such as: c:\snort\rules
var RULE_PATH /usr/local/snort/rules/rules
var SO_RULE_PATH /usr/local/snort/rules/so_rules
var PREPROC_RULE_PATH /usr/local/snort/rules/preproc_rules

###################################################
# Step #6: Configure output plugins
# For more information, see Snort Manual, Configuring Snort - Output Modules
###################################################

# syslog
output alert_syslog: LOG_AUTH LOG_ALERT

# pcap
# output log_tcpdump: tcpdump.log

# database
output database: alert, mysql,user=snort password=senhaBancoSnortmysql dbname=snort host=192.168.0.65

output database: log, mysql,dbname=snort username=snort password=senhaBancoSnortmysql host=192.168.0.65

###################################################
# Step #7: Customize your rule set
# For more information, see Snort Manual, Writing Snort Rules
###################################################


Para debugar habilitei também o output dos alertas e logs do snort para o syslog e sua saida esta sendo escrita no /var/log/messages.
6) Para testar inicie o snort, acompanhe a saída e se ocorrer algum erro a inicialização será interrompida e vc poderá verificar qual o motivo para o erro:

# /usr/local/snort/bin/snort -c /usr/local/etc/snort/snort.conf


Para coloca-lo na inicialização do S.O e setar alguns parametros como interface que o snort irá escutar, coloca o seu processo em back ground etc, então criei um script para o rc.d(lembrando que neste caso estou utilizando o FreeBSD). Abaixo o script snort dentro da pasta /usr/local/etc/rc.d:

#!/bin/sh
Exp $

# PROVIDE: snort
# REQUIRE: DAEMON
# BEFORE: LOGIN
# KEYWORD: shutdown

. /etc/rc.subr

name="snort"

rcvar="`set_rcvar`"

load_rc_config $name

: ${snort_enable="YES"}
: ${snort_if_listen="re0"}
: ${snort_config_file="/usr/local/etc/snort/snort.conf"}

command="/usr/local/sbin/snort/${name}"
command_args="-q -D -i ${snort_if_listen} -c ${snort_config_file}"
procname="/usr/local/sbin/snort/snort"
pidfile="/var/run/${name}_${snort_if_listen}.pid"

run_rc_command "$1"


Já no arquivo /etc/rc.conf, ahbilito o mesmo para carregar na inicialização e seto alguns parametros:

#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
# SNORT
#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
snort_enable="YES"
snort_if_listen="re1"
snort_config_file="/usr/local/etc/snort/snort.conf"


Pronto! Agora você já possui o snort na inicialização...

Observações:

- No arquivo snort.conf habilite rules/regras que sejam relevantes a sua rede, por exemplo, você não precisa deixar habilitada a regra para serviços mysql se você não possui nenhum servidor mysql em sua rede... Outra coisa importante também, é definir bem as váriaveis do seu arquivo snort.conf, para que se tenha um bom filtro e que se colete alertas que realmente sejam importantes para a segurança de sua rede e também para se evitar logs que sejam falsos positivo.

- Sempre mantenha suas regras atualizadas, para autmatizar essa atualização de regras utilizo o aplicativo oinkmaster pesquise como instala-lo e configura-lo é bastante simples.

- Utilize as regras do Emerging Threats que é uma comunidade de projetos open sources que desenvolve assinaturas/regras para o snort e que também possui outros projetos open sources ligados a segurança da informação. Conheça http://www.emergingthreats.net/index.php/about-et-mainmenu-43.html

- Existe um arquivo na pasta etc do snort chamado threshold.conf lá você poderá colocar limites para alertas que são gerados com muita frequência ocasionando em alto output se preferir você poderá suprimi-los também utilizando este arquivo threshold.conf.

quarta-feira, 16 de junho de 2010

Snort - Introdução ao IDS/IPS Snort

O Snort é um sistema de detecção de invasão baseado em rede (SDIR) de código fonte aberto, possuindo muitos recursos. Ele é sniffer que tem como diferencial a capacidade de inspecionar o payload do pacote, área que contém os dados do mesmo, fazendo o registros dos pacotes, além de detectar as invasões.

O Snort é um sistema avançado capaz de detectar quando um ataque
está sendo realizado e, baseado nas características do ataque, alterar ou remodelar sua configuração de acordo com as necessidades, e até avisar ao administrador do ambiente sobre o ataque.

Considera-se o Snort um SDI ligthweight, ou seja, ele pode ser colocado em funcionamento com muito pouco esforço tanto no sentido computacional quanto no sentido configuração e suporte.
Um característica marcante do Snort é a facilidade de criação de assinaturas de ataques. Profissionais da área de segurança da informação sabem da velocidade que os eventos ocorrem no mundo virtual. A prontidão, exatidão e rapidez são assuntos essenciais em se tratando de segurança. Como o Snort é um sistema de código aberto e apresenta linguagem fácil de criação de assinaturas, permite a pronta criação e adição de uma nova assinatura de ataque por parte do
administrador.

O Snort é uma ótima ferramenta, mas como todo aplicativo deve ser bem implementada. Devem ser aplicadas somente as assinaturas de ataques relevantes a realidade da rede. Por exemplo, não é necessário monitorar ataque a banco de dados MySQL se ele não se encontra em uso, o que ocasionaria apenas alertas irrelevantes. Além disso o banco de assinaturas deve estar constantemente atualizado evitando assim que ataques passem desapercebidos. O administrador tendo esses cuidados evita ou minimiza os falsos positivos e falsos negativos.

O profissional responsável pela rede deve certificar-se que o sistema onde o Snort esta operando é o mais seguro possível, ou seja, deve-se esta atendo a segurança do sistema operacional onde o Snort esta rodando. Uma invasão à máquina SDI invalida qualquer alerta do mesmo.
O Snort é um sistema que não requer grandes recursos de hardware. Os recursos de hardware necessário para o sistema operacional em uso atende ao Snort.

O Snort foi projetado para ser executado em uma grande gama de sistemas entre eles Linux, FreeBSD, NetBSD, OpenBSD, Solaris, MacOS, Windows, entre outros.

Existem alguns programas opcionais que podem ser instalados para melhorar/facilitar a administração do sistema. Cita-se os aplicativos para o mundo Linux. Os softwares são:

http://www.snort.org/downloads/additional-downloads/

FONTE: http://www.ginux.ufla.br/files/mono-BrunoSantos.pdf

segunda-feira, 31 de maio de 2010

IPFW - Instalação do IPFW com suporte ao IPFW2(+IPv6) sobre FreeBSD

Se ainda não conhece o IPFW leia o artigo com a introdução do mesmo no link abaixo:
http://conteudoopensource.blogspot.com/2010/05/introducao-ao-ipfw-instalando.html

Dica:
Esse processo do make para recompilar e instalar o novo kernel modificado, exige um pouco de memória RAM em torno de 292 MB, para não acabar utilizando o swap, se não houver memória suficiente o processo será morto pelo kernel e lançará uma excessão ocasionando na parada da instalação do novo kernel. Outro ponto importante é do espaço livre em disco utilize pelo menos 5 GB para a participação do seu FreeBSD.

O IPFW2 já vem nativo apartir da versão 5x do FreeBSD, não sendo necessária nenhuma modificação no kernel(inclusão do options IPFW2 no kernel) do sistema para utilizar o mesmo. A inclusão desse aopção acontecia apenas na versão 4x e anteriores do FreeBSD.

Utilizando para este artigo o FreeBSD 7.2


# cd /usr/src/sbin/ipfw

se o diretorio acima não existir você precisará instalar esses src's através do comando sysintall:

# sysinstall

Navegue pelo menu do sysinstall configure > distributions e marque a opção:

[ X ] ports

depois em configure > distributions > src maque as opções:

[ X ] base
[ X ] lib
[ X ] sbin
[ X ] sys

# vi /etc/make.conf

---> Insira:
IPFW2=true

Voltando ao userland :

# cd /usr/src/sbin/ipfw/

Recompile o ipfw:

# make clean


# make -DIPFW2


# make -DIPFW2 install

Recompile a libalias:

# cd /usr/src/lib/libalias/


# make clean


# make -DIPFW2


# make -DIPFW2 install

Vamos agora modificar o nosso kernel padrão(GENERIC) fazendo uma cópia do kernel default:

# cd /usr/src/sys/i386/conf/
# cp GENERIC NOME_DO_SEU_SERVIDOR


# vi NOME_DO_SEU_SERVIDOR

---> Procure a linha ident no kernel que foi copiado(NOME_DO_SEU_SERVIDOR) e modique-a colocando ao invés de:

ident GENERIC

para:

ident NOME_DO_SEU_SERVIDOR

Coloque essas linhas no final do kernel copiado(NOME_DO_SEU_SERVIDOR):

options IPFIREWALL
options IPFIREWALL_FORWARD
options IPFIREWALL_VERBOSE
options IPFIREWALL_VERBOSE_LIMIT=1000
options IPDIVERT
options DUMMYNET

-->salve e saia.

Vamos agora compilar e instalar o novo kernel(este passo é bastante demorado):

# cd /usr/src/

Compilando o kernel.

# make buildkernel KERNCONF=NOME_DO_SEU_SERVIDOR

Instalando o novo kernel.

# make installkernel KERNCONF=NOME_DO_SEU_SERVIDOR

Se tudo ocorreu bem, já temos o nosso kernel modificado bastando apenas reiniciar a máquina para utiliza-lo:

# reboot

Depois de reiniciar verifique que já estamos usando o novo kernel:

# uname -a

Instale um outro aplicativo que irá ajudar o ipfw a calcular os endereços de rede e host que são definidos no arquivo de regras do ipfirewall na forma "Ciderizada"(CIDR ex.: 189.87.34.2/21). Com isso você irá obter uma melhor perfomance no firewall:

# cd /usr/ports/net-mgmt/ipcalc/ && make install clean

Iremos configurar o rc.conf, para iniciar o firewall no boot e suas regras que serão pre-definidas por você, para isso basta editar /etc/rc.conf:

# vi /etc/rc.conf

-->Insira as seguintes linhas:

#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
# FIREWALL IPFW COM SUPORTE AO IPFW2 E IPV6
#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
firewall_enable="YES"
firewall_type="/tools/firewall/ipfw.rules"
firewall_quiet="NO"
firewall_logging="YES"

--> Onde firewall_type é seu arquivo de regras, falerei mais sobre as regras em outra postagem...

Iremos agora ativar o log
Crie os aquivo de log:

# mkdir /var/log/ipfw && touch /var/log/ipfw/ipfw.log

Depois configure o syslog:

# vi /etc/syslog.conf

--> Insira no final deste arquivo as linhas:
!ipfw
*.* /var/log/ipfw/ipfw.log

salve e saia e depois na shell enviei um hungup para o syslog:

# killall -HUP syslogd

quarta-feira, 26 de maio de 2010

pfSense - Introdução

Se estiver projetando a implantação de um servidor que contenha os serviços como: routing, daemon para roteamento RIP ,OSPF e BGP, Firewall, proxy, VPN, DHCP relay, DHCP server, DNS forwarder, DDNS, PPPoE server, Balanceamento de carga, Fail Over com carp, IDS, Traffic Graph por endereço IP entre outros .... você irá encontrar tudo isso e muito mais com o software opensource pfSense.

pfSense é livre, um open source customizado baseado na distribuição do S.O FreeBSD, adaptado para ser usado como um firewall e roteador.

Além de ser um poderoso firewall e roteador com uma plataforma flexível , ele inclui uma longa lista de ferramentas e um sistema de packages permitindo futuras expansabilidades, sem falar do potencial de segurança em termos de vulnerabilidades para a distribuição base. pfSense é um projeto popular com mais de 1 milhão de downloads desde seu início, e comprovada em inúmeras instalações que vão desde a proteção de pequenas redes domésticas e um Xbox até para grandes corporações, universidades e outras organizações protegendo milhares de dispositivos de rede.

Este projecto começou em 2004 como um fork do projeto m0n0wall, mas com foco para a instalação no PC ao invés do enfoque de software embarcado do m0n0wall. pfSense também oferece uma imagem incorporada para instalações em Compact Flash, porém não é o foco principal.

sexta-feira, 21 de maio de 2010

MediaWiki - Autenticando acesso via LDAP

A classe PHP LdapAuthentication, ou no linguajar do Wiki: "extensão LdapAuthentication" prover fucionalidades de autenticação e também algumas funcionalidades de autorização para o seu wiki, ele se integra com os seguintes serviços: Active Directory - Smartcard - Kerberos já disponiveis em sua rede.

Para instalação dessa funcionalidade em seu wiki você primeiramente deverá identificar a versão do seu mediawiki, para isso vá em páginas especiais do seu wiki depois vá no link Versões(/Especial:Version) e veja a sua versão essa funcionalidade esta disponivel para funcionar nos wikis aparti da versão 1.6+. Identificado a versão do seu wiki você deverá baixar a extensão LdapAuthentication em http://www.mediawiki.org/wiki/Special:ExtensionDistributor/LdapAuthentication de acordo com a versão do wiki.... Após ter baixado a extensão coloque no dirétorio extension do wiki, como mostra o comando abaixo:


# tar -xzf LdapAuthentication-MW1.13-r36354.tar.gz -C /var/www/mediawiki/extensions/LdapAuthentication/


Após ter feito isto você deverá configurar o seu LocalSetings.php, aqui utilizo a versão 1.11.0 do MediaWiki e a versão 1.10 do LdapAuthentication para realizar a autenticação dos usuário wiki utilizando o AD, configurações no LocalSettings.php:




/*
AUTENTICAÇAO NO AD PARA O WIKI
POR LEONARDO COUTO CONRADO
EM 20.04.2010

PROCURA NA BASE LDAP O OBJETO(USUÁIO DIGITADO NO LOGIN), A AUTENTICACAO FICA MAIS DINAMICA,POIS, NÃO SE LIGA DIRETO A UM UNICO OBJ(USUARIO LDAP)
ELE IRÁ AUTENTICAR UM CONJUNTO DE USUARIOS LDAP INFORMADO NO ATRIBUTO $wgLDAPBaseDNs - FUNCIONANDO-OK - EM PRODUÇÃO:
*/

require_once( "$IP/extensions/LdapAuthentication/LdapAuthentication.php" );
$wgAuth = new LdapAuthenticationPlugin();
$wgLDAPDomainNames = array("NOMEDOMINIO");
$wgLDAPServerNames = array("NOMEDOMINIO"=>"srvpdc1tecnotrlocal.nomedominio.local");
$wgLDAPEncryptionType = array("NOMEDOMINIO"=>"clear");
$wgLDAPUseLocal = false;
$wgMinimalPasswordLength = 1;

//A COLEÇÃO DE USUÁRIO QUE SERÁ PERMITIDO LOGAR NESTE WIKI SERÁ O CONTAINER(O.U.) LDAP ABAIXO:
$wgLDAPBaseDNs = array("NOMEDOMINIO"=>"OU=USUARIOS,OU=TRSSA,DC=nomedominio,DC=local");

//ATRIBUTO PARA CHECK, PESQUISA E COMPARA O QUE O USUÁRIO DIGITOU PARA REALIZAR O LOGIN NO WIKI, UTILIZANDO O TIPO DE ATRIBUTO LDAP sAMAccountName QUE CORRESPONDE AO NOME DE USUÁRIO(Exemplo.: sAMAccountName de Leonardo Conrado = leonardo.conrado):
$wgLDAPSearchAttributes = array("NOMEDOMINIO"=>"sAMAccountName");

//SOMENTE MEMBROS DESTE GRUPO SERÁ PERMITIDO LOGAR NO WIKI :
$wgLDAPGroupDN = "cn=GRUPO_WIKI,ou=USUARIOS,ou=TRSSA,dc=NOMEDOMINIO,dc=LOCAL";

//USUÁRIO PROXY PARA LEITURA DA BASE LDAP:
$wgLDAPProxyAgent = array("NOMEDOMINIO"=>"cn=winbind.user,cn=users,dc=NOMEDOMINIO,dc=LOCAL");

//SENHA DESTE USUÁRIO PROXY:
$wgLDAPProxyAgentPassword = array("NOMEDOMINIO"=>"linux123");

//CHECAR SE O USUÁRIO NÃO ESTAR DESABILITADO NO AD:
$wgLDAPRequireAuthAttribute = array("NOMEDOMINIO"=>true);

//The userAccountControl attribute has hex flags that specify information about a user's account a hex flag of 2 specifies the user's account is disabled:
$wgLDAPAuthAttribute = array("NOMEDOMINIO"=>"!(userAccountControl:1.2.840.113556.1.4.803:=2)");


quinta-feira, 20 de maio de 2010

Shell script - backup de seus bancos de dados Mysql em servidores remotos

Utilize o usuário root para o procedimento abaixo ou crie um usuário backup com uma senha forte, pois, iremos colocar senhas de BDs nos arquivos shell script, logo, por motivo de segurança é aconselhado realizar esta estratégia.

1 - Crie a seguinte estrutura de pastas no seu unix-like(Substitua o diretório sistema_mapas pelo o nome do seu sistema que deseja realizar o back-up):
# mkdir -p /backups_BDs_mysql/sistema_mapas/bkps

--->Somente o usuário root ou backup terá acesso ao conjunto de pastas por motivos de segurança, , então der o comando chmod -r:
# chmod -R 700 /backups_BDs_mysql/sistema_mapas/bkps

2 -Após isto, crie o seguinte arquivo shell script em /backups_BDs_mysql/sistema_mapas/:
# touch /backups_BDs_mysql/sistema_mapas/bkp_bd_mapas.sh

# chmod 755 /backups_BDs_mysql/sistema_mapas/bkp_bd_mapas.sh

# vi /backups_BDs_mysql/sistema_mapas/bkp_bd_mapas.sh

---> Insira o conteúdo abaixo no shell script:

#!/bin/bash

# Bkp banco mysql
# Por Leonardo Couto Conrado
# Em 19.10.2009

now=$(date +%Y%m%d)
clockNow=$(date +%d.%m.%Y-%H:%M)
nomeFile=$now.mapas.sql
pathBkp="/backups_BDs_mysql/sistema_mapas"

`mysqldump -u usuarioComAcessoAoBanco -psenhaDoBanco -h nomeOuIPDoServidorDeBanco --databases nomeDoBanco > $pathBkpMapas/bkps/$nomeFile`
`tar --absolute-names -czf $pathBkp/bkps/$nomeFile.tar.gz $pathBkpMapas/bkps/$nomeFile`
`rm -f $pathBkp/bkps/$nomeFile`

if [ $? -ne 0 ];
then
echo "$clockNow - $0, possiveis erros na linha acima ^" >>  /var/log/backups_BDs_mysql.log
else
echo "$clockNow - $0, possiveis erros na linha acima ^" >>  /var/log/backups_BDs_mysql.log
fi


3 - Crie os arquivos de log em /var/log/:
# touch /var/log/backups_BDs_mysql.log

4 - Teste executando o shell script:
# /backups_BDs_mysql/sistema_mapas/bkp_bd_mapas.sh

---> Se estiver tudo ok será gerado com arquivo tallbar comprimido(tar.gz) em /backups_BDs_mysql/sistema_mapas/bkps/ com o backup do banco, caso contrário verifique o problema provavelmente usuário, senha, nome do banco inserido incorreto no script...

5 - Para ser executado todos os dias coloque a tarefa agenda no cron, aqui no trabalho rodo o backup todos dias às 23:58 da noite:
# crontab -e -u root

---> Insira a linha abaixo para programar o backup:
58 23 * * * sh /backups_BDs_mysql/sistema_mapas/bkp_bd_mapas.sh 2>> /var/log/backups_BDs_mysql.log

---> Salve e saia do crontab

Pronto! Você pode utilizar este esquema de backup para outros sistemas no seu ambiente, este foi o exemplo para um único sistema aqui onde trabalho, agora só depende da sua criatividade!

domingo, 16 de maio de 2010

sexta-feira, 14 de maio de 2010

IPFW - Introdução ao IPFW sobre FreeBSD

O IPFW ou IPFIREWALL é o filtro de pacotes nativo do FreeBSD, sendo também chamado de IPFW, que é a interface para controle do IPFIREWALL. O IPFIREWALL faz o monitoramento de cada pacote em cada conexão feita à máquina, determinando por meio das regras definidas pelo IPFW qual é o tratamento dado a estes pacotes. As regras são lidas de cima para baixo, e podem determinar se o pacote será liberado, bloqueado, encaminhado etc.

Atualmente podemos ativar o suporte a IPFW2. O IPFW2 é uma nova versão do IPFW, com maior flexibilidade no formato das regras e algumas funcionalidades a mais, entre elas: suporte a regras não específicas para TCP ou UDP com número de porta, suporte a blocos OR, keepalives para sessões stateful e filtragem por cabeçalho MAC.

Ports FreeBSD - Instalando aplicativos via ports no FreeBSD

Existem duas maneiras de se instalar aplicativos de forma "autônomas" no freeBSD, sem se preocupar com as dependências de aplicativos e bibliotecas para o programa ao qual você deseja instalar. As duas formas são: através dos packages e a outra é através do ports do freeBSD, hoje falarei sobre os ports, de como atualizar a lista de ports e a melhor forma de encontrar o port e instala-lo no seu freeBSD.

Para quem não conhece o FreeBSD existe um mini curso falando um pouco sobre o freeBSD desde a sua história até sua instalação, acesse o site(http://www.ignx.com.br) e siga o roteiro do curso, para efetuar o login utilize usuário demo e senha demo.

Bem iremos então partir ao propósito deste post, que é a instalção de aplicativos via ports no freeBSD, mas afinal de contas o que é o ports?

- ports: é uma tecnologia do freeBSD que permite o administrador instalar aplicativos de forma autonôma, pois, ele irá abstrair a complexidade de instalação de softwares já conhecido do estilo unix-like em que o processo deste sistema basicamente se resume em: baixar , descompactar, localizar a documentação(README ou INSTALL) ,procurar e instalar dependências se for necessário, compilar e instalar o software que se deseja. Os arquivos de um port contém todas as informações necessárias para possibilitar que o sistema automatize o processo para você. Você executa um conjunto de comandos simples e o código fonte do aplicativo é automaticamente baixado, descompactado, corrigido, compilado e instalado para você. É interessante informar que os softwares para o freeBSD necessitam de pequenas modificações no código fonte para que ele seja compilado corretamente no freeBSD, mas se você estiver utilizando o ports, você estará instalando um aplicativo que foi deliberamente portado para o FreeBSD, No momento, mais de 12,800 aplicativos já foram disponibilizados desta forma para o freeBSD.

Antes que você possa instalar todas as aplicações de que necessita, você precisa saber do que precisa, e também como a aplicação se chama.

A lista de aplicativos disponiveis para FreeBSD cresce o tempo todo. Felizmente, existem diversas formas de procurar o que você necessita:

O web site do projeto FreeBSD mantém uma lista atualizada de todos os aplicativos disponiveis e na qual você pode executar buscas, em http://www.FreeBSD.org/ports/.

Dan Langille mantém o sítio web FreshPorts, em http://www.FreshPorts.org/. O FreshPorts rastreia as alterações nas aplicações na árvore do ports a medida que elas acontecem, permitindo que você monitore um ou mais ports, enviando um email para você quando eles forem atualizados.

Se você não sabe o nome da aplicação que deseja, consulte um sítio no estilo do FreshMeat (http://www.freshmeat.net/) para procurar um aplicativo que lhe atenda, quando encontrar volte ao sítio do FreeBSD e verifique se o aplicativo já foi incorporado ao ports.

Agora que você já o nome do ports passamos para o passo de instalação do mesmo, você primeiro precisa obter a coleção de ports, a qual é basicamente um conjunto de arquivos Makefiles, patches, e arquivos de descrição colocados sob /usr/ports

A primeira coisa que precisa ser explicada a alguém que está iniciando no uso do ports é que na verdade um port é composto por um ``conjunto de arquivos''. Em poucas palavras, um port é o conjunto mínimo de arquivos que diz ao sistema FreeBSD como compilar corretamente e como instalar um aplicativo. Cada port é composto por:

* Um arquivo Makefile. O Makefile contém várias instruções que definem como o aplicativo deve ser compilado e onde ele deve ser instalado em seu sistema.
* Um arquivo distinfo. Este arquivo contem informações sobre quais arquivos precisam ser obtidos para compilar o port e os seus respectivos checksums, os quais são utilizados para verificar se o o arquivo não foi corrompido durante o processo de transmissão, a verificação é realizada através do utilitário md5(1).
* Um diretório chamado files. Este diretório contém as correções necessárias para que o aplicativo possa ser compilado e instalado no FreeBSD. As correções são basicamente arquivos pequenos os quais especificam alterações a serem aplicadas a determinados arquivos. São arquivos em formato texto plano, e basicamente dizem `` remova a linha 10'' ou ``Altere a linha 26 para ...''. As correções são normalmente conhecidas como ``diffs'', pois são gerados pelo utilitário diff(1)

Este diretório também pode conter outros arquivos necessários para a compilação do aplicativo.
* Um arquivo pkg-descr. Este arquivo contém a descrição detalhada do aplicativo.
* Um arquivo pkg-plist. Este arquivo contém a lista de todos os arquivos que serão instalados pelo port. Ele também diz ao sistema de ports quais arquivos devem ser removidos durante a desinstalação do aplicativo.

Alguns ports possuem outros arquivos, como por exemplo pkg-message. O sistema de ports utiliza estes arquivos para lidar com sistuações especiais. Se você desejar maiores detalhes sobre estes arquivos, e sobre o sistema de ports em geral, consulte o FreeBSD Porter's Handbook .

Para atualizar a sua coleção de ports você deverá executar o seguinte comando(se for a primeira atualização a ser feita após instalação do freeBSD):
# portsnap fetch extract

ele irá atualizar toda a sua coleção de ports do seu freeBSD. Quando for atualizar a coleção de ports nas próximas vezes execute somente o comando abaixo:
# portsnap fetch update

Pronto já temos os ports atualizados o próximo passo agora é finalmente instala-lo, como já deve ser do conhecimento de todos os ports ficam localizados no seguinte caminho abaixo em seu freeBSD:
# cd /usr/ports

Encontrado o seu ports pelo nome é somente executar o seguinte comando dentro da pasta do aplicativo:
# make install clean

Exemplo, vamos instalar por exemplo o apache 2.2 então:
# cd /usr/ports/www/apache22/ && make install clean

Bem, se você utilizar proxy em sua rede talvez seja necessário passar isto para o fecth o aplicativo que baixar o programa para o ports realizar a instalação, para setar o proxy faça o seguinte procedimento:
# vi /etc/make.conf

> insira na ultima linha:

FETCH_ENV = HTTP_PROXY=http://user:passwd@proxy.name:80

Exemplo, proxy sem precisar passar usuário e senha e utilizando a porta 8080:

> insira na ultima linha:

FETCH_ENV = HTTP_PROXY=http://192.168.1.1:8080

Para listar os detalhes dos pacotes instalados através do pkg e ports no FreeBSD:
# pkg_info

Parametros úteis:

-a, mostra detalhes sobre todos os pacotes instalados como: Comment, Description, Required by.

-p nome_do_pkg
, mostra em que local/caminho estar instalado este pacote.

-c nome_do_pkg, mostra o comentário para este pacote.

-d nome_do_pkg, mostra o detalhes para este pacote.

-f nome_do_pkg, mostra packing list para este pacote.

-s nome_do_pkg, mostra o tamanho total do pacote instalado.

-o nome_do_pkg, mostra a "origin" caminho gravado na geração do pacote. Este caminho é o nome do diretório na coleção de ports do FreeBSD.

Para deinstalar um ports(package/aplicativo):

Acesse o diretório da coleção de ports que vc deseja deinstalar, por exemplo para deinstalar o apache22:

# cd /usr/ports/www/apache22 && make deinstall

e depois limpe o "lixo" deixado pela instalação do pacote apache22, ainda na pasta execute o comando abaixo:

# make clean

Ferramenta para limpar o lixo deixado pelo ports e packages:

# portsclean

Simples e fácil!

Espero ter ajudado!

Bibliografia:
http://www.openit.com.br/freebsd-hb/

Integração com winbind - Ingressando estação Linux a um dominio Windows AD

A Necessidade da Integração:

Mesmo que sua empresa opte por uma migração completa, ela não poderá ser realizada da noite para o dia, gerando (mesmo que temporariamente) um ambiente de rede heterogêneo, onde servidores e estações com ambos os sistemas deverão conviver com o menor impacto possível sobre as atividades da empresa.

Onde trabalho já coloquei diversas estações Linux(precisamente distros CentOs) no servidor de dominio windows server 2003. Abaixo descrevo passo à passo com realizar este procedimento e você terá sucesso no join de sua estação Linux ao servidor de dominio windows utilizando o winbind que faz o papel de middleware neste cenário de integração.

A configuração abaixada foi realizada utlizando a distro CentOS, ou seja, derivação RedHat:

1 – CONFIGURAÇÃO DA REDE:

Edite o arquivo /etc/sysconfig/network e coloque as linhas:

NETWORKING=yes
NETWORKING_IPV6=no
HOSTNAME=WKSSINAUXOPE001.EMPRESA.SDR

Altere as configurações do arquvivo /etc/hosts:

# Do not remove the following line, or various programs
# that require network functionality will fail.
127.0.0.1 localhost.localdomain localhost
#::1 localhost6.localdomain6 localhost6
10.0.0.60 WKSSINAUXOPE001.EMPRESA.SDR WKSSINAUXOPE001
# ACIMA COLOQUE O ENDEREÇO IP DO SERVIDOR DO DOMINIO E AO LADO COLOQUE O NOME DA MAQUINA LINUX, NÃO ME PERGUNTE PORQUE MAS SE VC MAPEAR O ENDEREÇO IP DO SERVIDOR PDC COM SEU NOME CORRESPONDENTE NÃO FUNCIONA! VAI ENTENDER NÉ?

Configuração do DNS (resolver)

a.Edite o arquivo /etc/resolv.conf e coloque as informações referentes ao domínio que você criou no w2003:

nameserver 10.0.0.60
domain empresa.sdr
search empresa.sdr

b.Teste

# ping  srvpdc1tecnotrsdr

# dig empresa.sdr NS


2 - CONFIGURAÇÃO DO KERBEROS

a.Edite o arquivo /etc/krb5.conf e coloque as linhas abaixo, porém comente algumas linhas que são de exemplo no do arquivo padrão diferentes das que estão aqui listadas.

[libdefaults]
default_realm = EMPRESA.SDR
dns_lookup_realm = false
dns_lookup_kdc = false
clockskew=11001

[realms]
EMPRESA.SDR = {
kdc = srvpdc1tecnotrsdr.empresa.sdr:88
admin_server = srvpdc1tecnotrsdr.empresa.sdr:749
default_domain = empresa.sdr
}

[domain_realm]
.empresa.sdr = EMPRESA.SDR
empresa.sdr = EMPRESA.SDR

→ O arquivo final ficará parecido a este:

[logging]
default = FILE:/var/log/krb5libs.log
kdc = FILE:/var/log/krb5kdc.log
admin_server = FILE:/var/log/kadmind.log

[libdefaults]
default_realm = EMPRESA.SDR
dns_lookup_realm = false
dns_lookup_kdc = false
clockskew=11001

[realms]
EMPRESA.SDR = {
kdc = srvpdc1tecnotrsdr.empresa.sdr:88
admin_server = srvpdc1tecnotrsdr.empresa.sdr:749
default_domain = empresa.sdr
}

[domain_realm]

.empresa.sdr = EMPRESA.SDR
empresa.sdr = EMPRESA.SDR

[appdefaults]
pam = {
debug = false
ticket_lifetime = 36000
renew_lifetime = 36000
forwardable = true
krb4_convert = false
}

3 - CONFIGURAÇÃO DO SAMBA:

a.Faça uma copia do /etc/samba/smb.conf e crie um novo com o conteúdo abaixo. Fazendo as devidas correções:

Deve ser instalados esses pacotes do samba(não necessariamente nestas versões):

samba-common-3.0.33-3.7.el5_3.1
samba-3.0.33-3.7.el5_3.1
samba-client-3.0.33-3.7.el5_3.1

[global]

security = ADS
password server = 10.0.0.60
realm = EMPRESA.SDR
workgroup = EMPRESA
server string = WKSSINAUXOPE001
encrypt passwords = yes
name resolve order = wins lmhosts bcast
wins server = 10.0.0.60

winbind separator = /
winbind cache time = 7200
idmap uid = 10000-30000
winbind gid = 10000-30000
winbind enum users = yes
winbind enum groups = yes
template homedir = /home/%U
template shell = /bin/bash
winbind use default domain = yes

4 - COLOCANDO A MÁQUINA NO DOMINIO:

a.Acerte o horario da máquina com o servidor AD (lembra do kerberos?), o kerberos não irá aceitar autenticação de estações com atrasos superiores a 5 minutos.


# net time set -I 10.0.0.60

b.Inicie o Kerberos

→ Não necessariamente administrador, essa conta pode ser uma conta do domínio que seja do grupo operadores de conta:

# kinit administrador

Autenticou? Caso não. Reveja o processo.

c.Cadastre a máquina a dominio

→ Não necessariamente administrador, essa conta pode ser uma conta do domínio que seja do grupo operadores de conta:

# net ads join -U administrador


Que retorno você obteve?

5 - TESTE O SAMBA E O WINBIND:

a.Inicie o serviço do winbindd


# /etc/init.d/winbind start

b.Teste se o winbind está trazendo as contas do AD

# wbinfo -u


6 - FAÇA A CPNFIGURAÇÃO DO PAM E DO NSS PARA FAZER A INTEGRAÇÃO DE AUTENTICAÇÃO

a.Edite o arquivo /etc/nsswitch.conf e modifique as linhas de acordo com o exemplo baixo:

passwd: files winbind
shadow: files winbind
group: files winbind


→ O arquivo final ficará parecido a este:

#
# /etc/nsswitch.conf
#
# An example Name Service Switch config file. This file should be
# sorted with the most-used services at the beginning.
#
# The entry '[NOTFOUND=return]' means that the search for an
# entry should stop if the search in the previous entry turned
# up nothing. Note that if the search failed due to some other reason
# (like no NIS server responding) then the search continues with the
# next entry.
#
# Legal entries are:
#
# nisplus or nis+ Use NIS+ (NIS version 3)
# nis or yp Use NIS (NIS version 2), also called YP
# dns Use DNS (Domain Name Service)
# files Use the local files
# db Use the local database (.db) files
# compat Use NIS on compat mode
# hesiod Use Hesiod for user lookups
# [NOTFOUND=return] Stop searching if not found so far
#

# To use db, put the "db" in front of "files" for entries you want to be
# looked up first in the databases
#
# Example:
#passwd: db files nisplus nis
#shadow: db files nisplus nis
#group: db files nisplus nis

passwd: files winbind
shadow: files winbind
group: files winbind



#hosts: db files nisplus nis dns
hosts: files dns

# Example - obey only what nisplus tells us...
#services: nisplus [NOTFOUND=return] files
#networks: nisplus [NOTFOUND=return] files
#protocols: nisplus [NOTFOUND=return] files
#rpc: nisplus [NOTFOUND=return] files
#ethers: nisplus [NOTFOUND=return] files
#netmasks: nisplus [NOTFOUND=return] files

bootparams: nisplus [NOTFOUND=return] files

ethers: files
netmasks: files
networks: files
protocols: files
rpc: files
services: files

netgroup: nisplus

publickey: nisplus

automount: files nisplus
aliases: files nisplus

b.Teste

# getent passwd

c.Edite o arquivo /etc/pam.d/system-auth conforme abaixo. Adicione as linhas abaixo nas seções auth, account e session:

auth sufficient /lib/security/pam_winbind.so
account sufficient /lib/security/pam_winbind.so
session required pam_mkhomedir.so skel=/etc/skel/ umask=0022

→ O arquivo final ficará parecido a este:

auth required pam_env.so
auth sufficient pam_unix.so likeauth nullok
auth sufficient pam_krb5.so use_first_pass
auth sufficient pam_winbind.so use_first_pass
auth required pam_deny.so

account required pam_unix.so
account sufficient pam_succeed_if.so uid < retry="3" skel="/etc/skel/" umask="0022" success="1" default="ignore]">@localhost

Pronto se tudo ocorreu com deveria sua estação linux estar dentro do dominio Windows. Existe outras maneiras de inserir sua estação a um dominio Windows como por exemplo utilizando ldap do linux ou o pacote gráfico likewise AD no Ubuntu, mas ai já fica a critério e necessidade de cada um...

Seguidores