[tutorial] criar sniffer com o modulo Net::Pcap

Postagem de conteúdo sobre programação perl
Post Reply
User avatar
Kodo no Kami
Admin
Admin
Posts: 723
Joined: Fri Jan 02, 2015 1:56 pm
Contact:

[tutorial] criar sniffer com o modulo Net::Pcap

Post by Kodo no Kami » Sat Jun 24, 2017 4:42 am

e ae galera andei sumidão esses meses (ainda estou '-' ), eu estava empacado com algumas coisas sem muita importancia e tambem com o novo ebook que logo logo vou esta postando ele assim que terminar (esse ano sera sobre kamasut... digo digo sera sobre a linguagem assembly), como faz um tempinho que não escrevo sobre nenhum assunto então resolvi escrever esse tutorial (assim o povo sabe que ainda estou vivo ou nao fui preso ainda '-' ), bom galera nesse tutorial vamos aprender desenvolver nosso proprio sniffer de rede na linguagem perl (estava indeciso se deveria escrever esse tutorial para C ou para python, como o perl é vida entao fds vai ser ele e pronto), um sniffer é um programa que captura pacotes de redes passados pela maquina ou pela propria rede quando esta atuando em modo promiscuo, em modo promiscuo depende esclusivamente da topologia ou do que os interliga com isso funcionando melhor em hub e nao em um switch ou roteador (claro que existem tecnicas que permite a captura de pacotes como a inundação na tabela do swtich para transformar ele em um hub ou spoofing no roteador porem vamos nos limitar apenas a criação do nosso sniffer), um sniffer é usado para diversos fins na mão de um adminstrador de rede pode ser usado para analise e manuteção da rede, na mão de um analista em segurança da info pode ser usado como detector de intrusão os IDS passivos, na mão daquele seu vizinho que voce rouba internet pode ser usado para rouba suas senhas quando voce entrar em algum site, na mão do seu provedor pode ser usado para te espionar e depois te dedurar para governo ou vender suas info (viva o marco civil da internet '-' ), como hoje eu não escutei o balaio bizarro então vamos batizar o nosso sniffer em homenagem aos locutores gatorro, gaspar e tiosky com o nome de "futabu na veia" kkkk (sei que ninguem vai entender a piada entao fds continuando o tutorial), para o nosso sniffer vamos usar o modulo Net::Pcap que não vem junto com o perl deve ser baixado pelo cpan (não vou abordar a instalação dele é bem simples), para começar declaramos o modulo no nosso script

Code: Select all

#!/usr/bin/perl

use Net::Pcap;
com o modulo declarado podemos usar as funções sendo que uma delas é o pcap_lookupdev que retorna a interface de rede atual, passamos como argumento o ponteiro de um variavel que sera armazenado o erro

Code: Select all

#!/usr/bin/perl

use Net::Pcap;

my $kodoint = pcap_lookupdev(\$erro);
print $kodoint . "\n";
Image

podemos retornar todas as interfaces com a função pcap_findalldevs

Code: Select all

#!/usr/bin/perl

use Net::Pcap;

my @kodoint = pcap_findalldevs(\$erro);

foreach my $kint(@kodoint){
	print $kint . "\n";
}
Image

para a gente capturar pacotes de uma interface ativa temos que especificar qual interface vamos capturar para isso usamos a função pcap_open_live, nessa função passamos como argumento a interface de rede (podemos usar o pcap_lookupdev para descobrir qual ou colocar o nome), o tamanho do pacote, se esta em modo promiscuo ou nao, tenpo em ms (podemos colocar 0 para infinito), ponteiro para uma varaivel para armazenar o erro, tambem armazenamos o retorno em uma variavel para manipular em outras funções depois no caso sendo o handle

Code: Select all

#!/usr/bin/perl

use Net::Pcap;

my $kodo = pcap_open_live("eth0",1024,1,0,\$erro);
para captura pacote por pacote usamos a função pcap_next sera capturado apenas um pacote, passamos como argumento o handle tambem passamos um ponteiro do tipo hash que seria o cabeçalho daquele pacote o (pkthdr), o retorno da função seria o pacote em si (lembrando que não esta formatado então se a gente exibir ele vai ter caracteres nao imprimiveis um sniffer raw)

Code: Select all

#!/usr/bin/perl

use Net::Pcap;

my $kodo = pcap_open_live("eth0",1024,1,0,\$erro);
my $kami = pcap_next($kodo,\%info); 
print $kami;
Image

outra função semelhante ao pcap_next é o pcap_next_ex, a sua diferença que passamos um terceiro argumento que seria a variavel que vamos armazenar o pacote

Code: Select all

#!/usr/bin/perl

use Net::Pcap;

my $kodo = pcap_open_live("eth0",1024,1,0,\$erro);
pcap_next_ex($kodo,\%info,\$kami); 
print $kami;
podemos prender o programa em um loop para ficar capturando novos pacote

Code: Select all

#!/usr/bin/perl

use Net::Pcap;

my $kodo = pcap_open_live("eth0",1024,1,0,\$erro);
my $kami;

while(1){
	$kami = pcap_next($kodo,\%info); 
	print $kami;
}
tambem podemos combinar nosso sniffer com ferramentas do proprio linux como xxd para exibir os caracteres em formato hexadecimal ao inves do formato raw

Code: Select all

# perl kodo.pl | xxd
Image

podemos imprimir eles em hexadecimal bastando criar essa funcionalidade lendo cada byte do pacote e imprimindo em formato hex

Code: Select all

#!/usr/bin/perl

use Net::Pcap;

my $kodo = pcap_open_live("eth0",1024,1,0,\$erro);
my $kami;
my $cont;

while(1){
   $kami = pcap_next($kodo,\%info);
   
   for($cont = 0; $cont < $info{len} ; $cont++){
	   printf "%x ", ord(substr($kami,$cont,1));
   }
   print "\n======================\n";
}
Image

o proprio pcap permite uma função de loop assim nao precisamos ficar lendo o pcap_next em um loop podemos utilizar a função pcap_loop, essa função passamos como argumento o handle, a quantidade de pacotes lido antes de cessar o loop (colocamos 0 para loop infinito), uma função de callback para onde sera chamado a cada novo pacote, o usuario

Code: Select all

#!/usr/bin/perl

use Net::Pcap;

my $kodo = pcap_open_live("eth0",1024,1,0,\$erro);
pcap_loop($kodo,0,\&kami,"");

sub kami{
	my ($usu, $info, $pacote) = @_;
	print $pacote;
}
podemos armazenar pacotes capturados em formato pcap, para fazer isso temos que abrir um arquivo com a função pcap_dump_open, passamos como argumento para ele o handle da interface, e o arquivo, tambem atribuimos o retorno para uma variavel que é o handle do arquivo

Code: Select all

#!/usr/bin/perl

use Net::Pcap;

my $kodo = pcap_open_live("eth0",1024,1,0,\$erro);
my $arq = pcap_dump_open($kodo,"arquivo.pcap");
depois disso basta a gente ler o pacote com pcap_next ou pcap_loop e armazenar com a função pcap_dump, nessa função passamos como argumento a variavel que é o handle do arquivo, o cabeçalho e o pacote

Code: Select all

#!/usr/bin/perl

use Net::Pcap;

my $kodo = pcap_open_live("eth0",1024,1,0,\$erro);
my $arq = pcap_dump_open($kodo,"arquivo.pcap");
pcap_loop($kodo,0,\&kami,"");

sub kami{
	($usu, $info, $pacote) = @_;
	
	pcap_dump($arq,$info,$pacote);
}
tambem podemos fechar o arquivo com a função pcap_dump_close, podemos fechar o arquivo para salver nele caso o dump seja muito longo e tem risco de perder caso o sistema seja desligado ou caso o dump seja finalizado ou precise acessar o arquivo com outro programa

Code: Select all

#!/usr/bin/perl

use Net::Pcap;

my $kodo = pcap_open_live("eth0",1024,1,0,\$erro);
my $arq = pcap_dump_open($kodo,"arquivo.pcap");
my $pacote = pcap_next($kodo,\%info);
pcap_dump($arq,\%info,$pacote);
pcap_dump_close($arq);
depois que é armazenado no arquivo podemos ler esse arquivo com wireshark ou ate mesmo com o tcpdump ou qualquer outro que leia formato pcap

Code: Select all

tcpdump -r arquivo.pcap
Image

podemos abrir um arquivos pcap usando a função pcap_open_offilne, nele passamos como argumento o arquivo e uma variavel de erro

Code: Select all

#!/usr/bin/perl

use Net::Pcap;

my $kodo = pcap_open_offline("arquivo.pcap",\$erro);
depois de aberto podemos ler ele com a função pcap_next ou pcap_loop

Code: Select all

#!/usr/bin/perl

use Net::Pcap;

my $kodo = pcap_open_offline("arquivo.pcap",\$erro);
my $kami = pcap_next($kodo,\%info);
print $kami;
tambem podemos fechar o arquivo com a função pcap_close_offline

Code: Select all

#!/usr/bin/perl

use Net::Pcap;

my $kodo = pcap_open_offline("arquivo.pcap",\$erro);
my $kami = pcap_next($kodo,\%info);
print $kami;
pcap_close_offline($kodo);
é possivel aplicar filtros e capturar pacotes especificos, para a gente aplicar um filtro temos que criar um com a função pcap_compile e depois aplicar ele com a função pcap_setfilter, na função pcap_compile passamos como argumento o handle da interface, depois o ponteiro de uma variavel que sera o nosso filtro, depois o filtro, depois dois valoress que serve para otimização e mascara (colocamos esses como 0)

Code: Select all

#!/usr/bin/perl

use Net::Pcap;

my $kodo = pcap_open_live("eth0",1024,0,1,\$erro);
pcap_compile($kodo,\$filtro,"port 21",0,0);
para a gente aplicar o filtro usamos a função pcap_setfilter, passamos como argumento para ela o handle da interface seguido da variavel do filtro

Code: Select all

#!/usr/bin/perl

use Net::Pcap;

my $kodo = pcap_open_live("eth0",1024,0,1,\$erro);
pcap_compile($kodo,\$filtro,"port 21",0,0);
pcap_setfilter($kodo,$filtro);
pcap_loop($kodo,0,\&kami,"");

sub kami{
	($usu, $info, $pacote) = @_;
	
	print $pacote;
}
Image

bom galera é isso esse tutorial termina aqui porem tem muitas funções que não vou citar nele inclusive algumas usadas para injetar pacotes na rede, com as funções desse tutorial ja é possivel criar muitas coisas como ferramentas de detectação de intrusão como os IDS passivos igual o snort, sniffers especificos para roubo de senhas de protocolos especificos como o dsniff, programas de estatisticas de rede como o iptraf, programas para armazenamento de logs de pacotes e etc ^^

by kodo no kami
Image

que desagradavel ~ mirai kuriyama

User avatar
51M0N
Admin
Admin
Posts: 872
Joined: Fri Jan 02, 2015 2:06 pm

Re: [tutorial] criar sniffer com o modulo Net::Pcap

Post by 51M0N » Sat Jun 24, 2017 8:39 am

da para fazer altas coisas com o modulo Net::Pcap, muito bom kodo sempre postando conteúdos diferentes.
Image
"Você, eu, nem ninguém vai bater tão duro como a vida. Mas não se trata de bater duro. Se trata de quanto você aguenta apanhar e seguir em frente (...). É assim que se consegue vencer." by Rocky Balboa

Post Reply

Return to “Perl”