Professor Preceptor: Adeilson Marques
Professores Secundários: Elielton Oliveira e Vinicius
Discentes: Pedro Henrique Vitorino Grachet, Matheus Alves Rocha, Dhiego
Ferreira Conceição
E-book sobre JpCap
Araguatins – TO
2019
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Guias e Dicas
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Encontrar documentos
Prepare-se para as provas com trabalhos de outros alunos como você, aqui na Docsity
Encontra documentos específicos para os exames da tua universidade
Encontra documentos específicos para os exames da tua universidade
Videoaulas
Prepare-se com as videoaulas e exercícios resolvidos criados a partir da grade da sua Universidade
Quiz
Responda perguntas de provas passadas e avalie sua preparação.
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Este tutorial é sobre a instalação do JPCAP
Tipologia: Resumos
2020
1 / 17
Esta página não é visível na pré-visualização
Não perca as partes importantes!
Documentos relacionados
Pré-visualização parcial do texto
Baixe Jpcap Tutorial - Windows Tutorial e outras Resumos em PDF para Matérias técnicas, somente na Docsity!
Professor Preceptor: Adeilson Marques
Professores Secundários: Elielton Oliveira e Vinicius
Discentes: Pedro Henrique Vitorino Grachet, Matheus Alves Rocha, Dhiego
Ferreira Conceição
E-book sobre JpCap
Araguatins – TO
Analise de Protocolos
De maneira geral, um analisador de protocolos é um software que captura
o tráfego de rede (pacotes) em uma interface (a placa de rede do seu
computador por exemplo).
Um analisador de protocolos é popularmente conhecido como sniffer de
redes. Ele identifica, reconstrói, organiza, e disponibiliza os dados capturados de
forma visual e hierarquizada, através de uma interface de usuário.
Exemplo: WIRESHARK
Mas como fazemos para analisar protocolos de redes sem utilizar um
software específico? Através de uma linguagem de programação, por exemplo.
Bem, o Jpcap é exatamente uma dessas alternativas, veremos no que ele
consiste logo abaixo.
O que é JPCAP?
Antes de falarmos de Jpcap, primeiros temos que entender o que Pcap.
Assim sendo, PCAP (Packet Capture) consiste numa API para a captura de
pacotes de rede. Em sistemas baseados em Unix o Pcap é implementado na
biblioteca LibPcap, no caso dos sistemas Windows este encontra-se
implementado na biblioteca WinPcap.
import jpcap.JpcapCaptor;
import jpcap.NetworkInterface;
import jpcap.NetworkInterfaceAddress;
public class JpcapInterfaces {
public static String hex2String(byte [] input){
String output = "";
for (int i = 0 ; i < input.length- 1 ; i++) {
output += Integer.toHexString(input[i] & 0xff) + ":";
output += Integer.toHexString(input[input.length-1] & 0xff);
return output;
public static void main(String args[]) {
//Obtém a lista de interfaces de rede no sistema.
NetworkInterface[] interfaces = JpcapCaptor.getDeviceList();
for (NetworkInterface ni : interfaces) {
System.out.println("----------------------------------------- --------");
//Nome da interface.
System.out.println("Nome: " + ni.name);
//Descrição da interface caso exista.
System.out.println("Descrição: " + ni.description);
//DataLink da interface.
System.out.println("Nome da DataLink : " + ni.datalink_name);
//Descrição do DataLink caso exista.
System.out.println("Descrição da DataLink : " + ni.datalink_description);
//MAC Address da interface.
System.out.println("MAC Address: "+ hex2String(ni.mac_address));
for(NetworkInterfaceAddress a : ni.addresses){
//Endereço de IP da interface.
System.out.println("IP: " + a.address.getHostAddress());
//Endereço de Broadcast da interface.
System.out.println("BroadCast: " + a.broadcast);
//Mascara de SubRede.
System.out.println("SubNet: " + a.subnet.getHostAddress());
//Em caso de ligações P2P o endereço de destino.
System.out.println("Destinho P2P: " + a.destination);
System.out.println("------------------------------------n");
Com o exemplo acima podemos ver como é simples obter as interfaces
de rede disponíveis no sistema bem como todos os seus dados, alguns deles
Esta saída corresponde a um sistema Linux, noutros sistemas podem aparecer
diferenças nomeadamente nos nomes dos dispositivos. Por exemplo, pode
aparecer algo como DeviceNPF_{C3F5996D-FB82- 4311 - A205-25B7761897B9}
ao invés do simples eth0.
Para que as nossas aplicações consigam utilizar o jpcap correctamente estas
devem ser executadas com permissões de admin, caso contrário é possível que
não sejam obtidos resultados, uma vez que o sistema pcap necessita dessas
permissões para realizar as operações sobre as interfaces.
Preparar a interface de rede para captura
Para preparar a captura de pacotes de rede basta utilizar o método
static openDevice da classe JpcapCaptor , este método abre a interface
escolhida e prepara a captura de pacotes. Abaixo podemos ver como usar este
método
NetworkInterface[] interfaces = JpcapCaptor.getDeviceList();
//openDevice(NetworkInterface interface, int snaplen, boolean promics, int
to_ms)
JpcapCaptor captor = JpcapCaptor.openDevice(interfaces[0], 65535, false ,
Como podemos ver são passados quatro argumentos ao
método openDevice , o primeiro argumento é a interface a ser utilizada na
captura, neste caso vamos utilizar o primeiro interface da lista ou seja o "eth0".
O segundo argumento corresponde ao numero de máximo bytes a serem
capturados de cada vez, o terceiro argumento irá dizer se a captura será em
modo promiscuo (true) ou não (false). O modo promiscuo permite capturar
pacotes de rede mesmo que a sua origem ou destino não seja a da interface
aberto para captura. O modo não promiscuo apenas captura pacotes cujo
destino ou origem se a interface escolhida. O último argumento corresponde ao
timeout em milissegundos dado para a captura de pacotes.
Capturar pacotes da interface de rede
Vamos agora passar à captura dos pacotes, o processo pode ser feito de duas
formas diferentes, mas que atingem o mesmo fim. Podemos utilizar a
forma callback ou one-by-one.
A forma callback passa pela utilização dos
métodos processPacket ou loopPacket da classe JpcapCaptor e pela
implementação da interface PacketReceiver. De uma forma resumida o que
vamos fazer é criar uma classe que implementa a
interface PacketReceiver onde implementamos o método receivePacket que irá
conter o que deverá ser feito a cada pacote capturado. Depois de implementada
a interface, usamos o método processPacket ou loopPacket , ambos atingem o
mesmo fim com a diferença que no processPacket é compativel com timeout e
modo non blocking.
A forma one-by-one é a mais "primitiva" e a mais flexível dado que é possível
controlar todas as acções feitas sobre o pacote. Para isso utilizamos o
método getPacket da classe JpcapCaptor , este método como o nome indica
retorna um pacote capturado, assim apenas temos que criar um mecanismo que
irá repetir o processo quantas vezes quisermos.
Vamos para isso ver um pequeno exemplo que captura 20 pacotes e imprime na
consola o IP de origem/destino bem como as portas correspondentes e o
tamanho do pacote.
import java.io.IOException;
import jpcap.JpcapCaptor;
import jpcap.NetworkInterface;
import jpcap.packet.Packet;
import jpcap.packet.TCPPacket;
import jpcap.packet.UDPPacket;
public class OpenInterface {
public static void main(String args []){
//Lista de interfaces de rede no sistema.
System.out.println("SRC: " + udp.src_ip.getHostAddress() + ":" + udp.src_port +
" tDST: " + udp.dst_ip.getHostAddress() +":" + udp.dst_port +
" tSize = " + udp.length + " bytes");
i++;
//Fecha a captura de pacotes.
captor.close();
catch(IOException io){
System.out.println(io.getMessage());
catch(Exception e){
System.out.println(e.getMessage());
Como podemos ver apenas foram processados os pacotes UDP e TCP, mas
existem outros como por exemplo ARPPacket, DatalinkPacket, ICMPPacket
entre outros. Este pequeno exemplo irá gerar um ouput semelhante ao que se
segue a baixo sem os * que foram colocados por motivos óbvios de privacidade
e segurança.
SRC: 7.177.05.30:1670 DST: 19.16..13:49153 Size = 40 bytes
SRC: 19.16..13:49153 DST: 7.177.05.30:1670 Size = 1119 bytes
SRC: 3.30.6.103:74* DST: 19.16..13:49153 Size = 40 bytes
SRC: 19.16..13:49153 DST: 3.30.6.103:74* Size = 328 bytes
SRC: 19.16..13:579*5 DST: 1.111.49.15:33655 Size = 445 bytes
SRC: 4.13.19.4:60000 DST: 19.16..1*3:49794 Size = 58 bytes
SRC: 19.16..13:49794 DST: 4.13.19.*4:60000 Size = 160 bytes
SRC: 7.93.3.55:164 DST: 19.16..1*3:49153 Size = 40 bytes
SRC: 19.16..13:49153 DST: 7.93.3.55:16*4 Size = 550 bytes
SRC: 91.1.50.11:7075 DST: 19.16..13:49153 Size = 73 bytes
SRC: 19.16..13:49153 DST: 91.1.50.11:7075 Size = 93 bytes
SRC: 0.99.194.194:4990 DST: 19.16..1*3:50043 Size = 58 bytes
SRC: 19.16..13:50043 DST: 0.99.194.194:49*90 Size = 260 bytes
SRC: .7.00.1:60053 DST: 19.16..13:469** Size = 313 bytes
SRC: 19.16..13:469** DST: .7.00.1:60053 Size = 58 bytes
SRC: 17.13.7.9:6000 DST: 19.16..13:5047 Size = 52 bytes
Embora neste exemplo apenas tenhamos extraído estes dados é possível
extrair ainda mais dados dos pacotes, como por exemplo os dados (data)
Filtragem por Protocolo
Sintaxe Descrição
ip Captura todos os pacotes de IP
arp Captura todos os pacotes ARP
rarp Captura todos os pacotes ARP inversos
tcp Captura todos os pacotes TCP
udp Captura todos os pacotes UDP
icmp Captura todos os pacotes ICPM
Combinação de filtros
Sintaxe Descrição Exemplo
not Negação not src net 192.
and Concatenação tcp and src host 192.168.1.
or Alternância port 80 or port 8080
Acima temos a sintaxe principal que é possível utilizar para criar filtros, como podemos ver podem ser criados filtros por host, port, network, tipo de pacote e podemos ainda fazer combinações de filtros utilizando operações lógicas. Vamos agora ver um exemplo da utilização de filtros e iremos também ver neste exemplo como é possível ver os dados que são enviados nos pacotes.
import java.io.IOException;
import jpcap.JpcapCaptor;
import jpcap.NetworkInterface;
import jpcap.packet.TCPPacket;
public class JpcapFilter {
public static void main(String args []){
//Lista de interfaces de rede no sistema.
NetworkInterface[] interfaces = JpcapCaptor.getDeviceList();
try{
//Abre a interface 0 da lista.
JpcapCaptor captor = JpcapCaptor.openDevice(interfaces[ 0 ], 65535 , false , 20 );
//Captura apenas pacotes TCP com origem no host 192.168.1. e que
//tem como destino a porta 80 ou seja HTTP
captor.setFilter("tcp and src host 192.168.1.100 and dst port 80", true );
//Simples contador.
int i = 0 ;
//Cliclo para capturar 20 pacotes.
while(i < 20 ){
//Captura um pacote e converte para TCPPacket dado que apenas
//a capturar pacotes TCP.
TCPPacket p = (TCPPacket) captor.getPacket();
//Gera o output com a informação sobre o pacote
O que o programa vai fazer assumindo que o nosso IP corresponde ao
192.168.1.100 é capturar todos os pacotes TCP que são enviados pelo nosso
computador e que tem como destino a porta 80. De uma forma resumida vai
capturar todos os pedidos HTTP feitos por nós. Na realidade não irá capturar
todos mas apenas alguns, ou seja, irá capturar até encontrar um pacote que
contenha dados e irá gerar um output semelhante ao que se segue.
SRC: 192.168.1.100:49323 DST: 66.102.9.147:80 Size = 60 bytes
SRC: 192.168.1.100:49323 DST: 66.102.9.147:80 Size = 52 bytes
SRC: 192.168.1.100:49323 DST: 66.102.9.147:80 Size = 715 bytes
GET / HTTP/1.
Host: www.google.pt
User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.1.11) Gecko/20071204 Ubuntu/7.10 (gutsy) Firefox/2.0.0.
Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain ;q=0.8,image/png,/;q=0.
Accept-Language: pt-pt,pt;q=0.8,en;q=0.5,en-us;q=0.
Accept-Encoding: gzip,deflate
Accept-Charset: ISO- 8859 - 1 ,utf-8;q=0.7,*;q=0.
Keep-Alive: 300
Connection: keep-alive
Cookie: NID=17=BNGeDayJAh13ZHF6XFJ2mwo5N3rNTRu6WaFDUYmbgAC4pyT0kzPnSKN0qKAz_ajH2W jpqDZ92DXTdjhNyiG_s-Xwd4Mwr;
PREF=ID=8ed9295:TM=197383:LM=213911:IG=8:S=T7z-r65IhJ
O exemplo acima mostra o pedido feito pelo Firefox ao servidor www.google.pt,
como podemos ver trata-se de um pedido HTTP ao servidor.Assim encerramos
este artigo, neste momento estamos prontos a criar desde grandes aplicações a
pequenos utilitários de análise de pacotes de rede.
Referência Bibliográficas
https://wiki.portugal-a-
programar.pt/revistaprogramar_arquivo:18_edicao:pcap_em_java_com_jpcap
http://www.tcpdump.org/
https://www.winpcap.org