Vamos sniffar o que passa pela nossa interface do alvo e ver o que conseguimos pegar de interessante.

Primeiramente precisamos carregar o módulo sniffer com o comando use sniffer, em seguida, pedimos para listar as interfaces de rede com o comando sniffer_interfaces. Iremos iniciar nosso sniffer nesta interface indicada pelo número 1 com o comando "sniffer_start 1", podemos esperar o tempo que você achar conveniente.

Já foi tomar uma água? Uma cerveja? Tomou banho? Não? Ok! Não faz mal, vou salvar o que ele farejou até agora em um arquivo com extensão .cap, com o nome de sniffer, com o comando "sniffer_dump 1 /tmp/sniffer.cap", para eu poder analisá-lo com outra ferramenta mais intuitiva, e logo após, encerro o sniffing. Vejamos algumas informações sobre o arquivo sniffer.cap usando o capinfos. Vamos analisar o arquivo sniffer.cap com a ferramenta Wireshark. Basta abrir o Wireshark e ir em File > Open e apontar para o arquivo sniffer.cap. Agora veja a interface do Wireshark já com o arquivo sniffer.cap carregado. E as senhas em plaint-text heim? Perigooo!!! :| Ah! Você não gosta do Wireshark ou não quer usá-lo agora? Prefere o tcpdump? No problem! Vamos analisar o arquivo sniffer.cap com o tcpdump então, oras!!!

# tcpdump -n -r sniffer.cap

Se quiser ver as primeiras 10 linhas do arquivo, basta adicionar "| head -n 10" na frente do comando acima.

# tcpdump -n -r sniffer.cap | head -n 10

Vamos continuar com o sniffer, só que agora executando com o modo interativo do ruby, basta executar o comando irb e voilà! Seria interessante, para uma melhor compreensão, ter noções básicas da linguagem ruby. Como o modo interativo está "doido" para trabalhar, vamos lá.

Um pouco acima, quando executamos o comando use sniffer, por trás dos panos (ou cortinas!), estava executando a seguinte chamada API, client.core.use("sniffer") e quando executamos o comando sniffer_interfaces, estávamos invocando (sai capeta!) a chamada API, client.sniffer.interfaces().

Veja e compare as saídas abaixo. Olhe a imagem acima e repare que ao passar para o irb a chamada client.core.use("sniffer"), ele nos retorna true, nos confirmando que foi carregado com êxito. E quando passamos a chamada client.sniffer.interfaces(), nos retorna informações sobre a nossa interface, repare as saídas de ambas as saídas.

E a chamada para iniciarmos o sniffing? Cadê? Calma, está aqui! A chamada API é client.sniffer.capture_start(intf, maxp), vemos que a chamada aceita dois valores, intf é a identificação da interface, repare na imagem acima que conseguimos saber este valor executando a chamada client.sniffer.interfaces(), onde pegamos o valor de "idx". E o valor de maxp, é a quantidade máxima de pacotes que iremos armazenar no buffer. Ambos deverão ser valores inteiros.

Logo em seguida com a chamada client.sniffer.capture_stats(1) vemos o quanto já conseguimos snifar até o momento! Hora de analisar o que farejamos não? Ohh Yes! Lembra quando executamos o comando sniffer_dump? Pois é, agora vamos executar a sua chamada API que é identificada por client.sniffer.capture_dump(intf), nesta chamada obtemos do buffer as informações e já apagando-a, par ler os dados precisamos invocar o espírito do... Ops! Me empolguei! Como dizia, precisamos da chamada client.sniffer.capture_dump_read(intf,1024*512). Ok, já vimos como funciona mais ou menos internamente, agora podemos parar nosso sniffing com a chamada client.sniffer.capture_stop(1), passando a identificação do nossa interface, que equivale ao comando sniffer_stop 1. Poxa! Vamos parar de "cheirar" agora (isto me lembra um jogador famoso, deixa pra lá!).