Caso de Estudo da Biblioteca WinPcap

Daniel Braga Moura

Universidade Federal do Piauí

Departamento de Informática e Estatística

nsontt@yahoo.com.br

30 de Abril de 2006.

Abstract
Most Unix systems provide a set of system calls that allow applications to interact with
the network directly. These primitives are useful for example in packet capture
applications, which need to grab the data flowing through the network without any
further processing from the kernel. WinPcap is a newly proposed architecture that adds
these functionalities to Win32 operating systems. WinPcap includes a set of innovative
features (such as packet monitoring and packet injection) that are not available in
previous systems. This paper presents the details of the architecture and it shows its
excellent performance.

Keywords: packet capture applications, WinPcap, innovative

features.

Resumo
A maioria dos sistemas de Unix fornecem um conjunto de chamadas ao sistema que
permitem que as aplicações interajam com a rede diretamente. Estes primitivos são
úteis para o exemplo nas aplicações da captura de pacotes, que necessitam capturar os
dados que correm através da rede sem processar adicionalmente o kernel.. WinPcap é
uma arquitetura recentemente que oferece estas funcionalidades aos sistemas
operacionais Win32 .WinPcap inclui um conjunto de características inovadoras (tais
como a monitoração do pacote e a injeção do pacote) que não estão disponíveis em
sistemas precedentes. Este papel apresenta os detalhes da arquitetura e mostra seu
desempenho excelente.

Palavras - chave: Aplicações de captura de pacotes, WinPcap, características

inovadoras.
 Lista de Ilustrações

FIGURA 2.1 - Arquitetura do WinPcap ………………………………………... 08

2
 Lista de Siglas

BPF - Berkeley Packet Filter

HTTP – Hyper Text Transfer Protocol
IP – Internet Protocol
NPF - Netgroup Packet Filter
TCP – Transmission Control Protocol
TCP/IP – Transmission Control Protocol/Internet Protocol

3
 Sumário

1 WinPcap .................................................................................................05

2 Arquitetura do WinPcap ......................................................................06

3 Exemplos ................................................................................................09

3.1. SMP..........................................................................................................................09

3.2.Kdump.......................................................................................................................11

4 Ferramentas ...........................................................................................13

4.1. Ethereal.....................................................................................................................13

4.2. IM Sniffer.................................................................................................................13

5 Referências .............................................................................................14

4
1. WinPcap
WinPcap é uma biblioteca de código aberto para captura de pacotes e análise de rede
para a plataforma Win32.

Ela implementa o acesso direto ao tráfego da rede, sem a intermediação das

entidades relacionadas, como a pilha de protocolos.

As funcionalidades que a biblioteca fornece, são:

a) captura de pacotes, diretamente do adaptador de rede, destinados ao

microcomputador onde está instalada;

b) filtro de pacotes de acordo com as regras pré-estabelecidas pelo usuário;

c) transmite pacotes diretamente à rede;

d) análise de valores estatísticos no tráfego da rede.

WinPcap pode ser usada por diferentes tipos de aplicação de análise de rede,
pesquisando falhas na segurança e monitorando-a.

Aplicações que podem se beneficiar das vantagens da biblioteca são:

a) analisadores de rede e de protocolos;

b) monitores de rede;

c) loggers de tráfego;

d) geradores de tráfego;

e) pontes e routers em nível de usuário;

f) sistemas de detecção de intrusos da rede;

g) “varredores” da rede;

h) ferramentas de segurança.

WinPcap recebe e emite os pacotes independentemente do protocolo pai, como

TCP/IP. Isto significa que não pode obstruir, filtrar ou manipular o tráfego gerado por
outros programas na mesma máquina: simplesmente "aspiram" os pacotes que transitam
no fio. Conseqüentemente, não fornece a sustentação apropriada para aplicações como
formas do tráfego e firewalls pessoais.

5
 São duas as bibliotecas responsáveis pelo filtro de pacotes, sendo a de nível mais
baixo (packet.dll) responsável pela ligação dinâmica, ou seja, pode ser usada para
acessar diretamente as funções do driver com uma programação de interface
independente do sistema operacional Windows e uma de alto nível independente do
adaptador de rede e do sistema operacional (wpcap.dll).

2. Arquitetura do WinPcap
Desde que o BPF foi provado sendo uma arquitetura poderosa e estável, a estrutura
básica de WinPcap (mostrado em figura 3.1) retém os módulos os mais importantes do
BPF: uma máquina filtrando, dois buffers (kernel e usuário) e um par de bibliotecas no
nível de usuário. Entretanto, WinPcap tem algumas diferenças substanciais na estrutura
e no comportamento da pilha da captação, e pode ser visto como a evolução do BPF.

O processo de filtramento é iniciado por um componente nível-usuário (libpcap-

compatível) que possa aceitar um filtro usuário-definido ( "escolhe acima todos os
pacotes do UDP"), compila-os em transformações de instrução falsa (" se o pacote for
IP e o campo do tipo do protocolo for igual a 17, então retorna verdadeiro"), emite estas
instruções à máquina filtrando, e ativa esse código. Em seu handle, o módulo do kernel
deve poder executar estas instruções; conseqüentemente deve ter de "uma máquina
virtual BPF" que execute o pseudo-código em todos os pacotes que estão entrando. Esta
máquina de filtramento BPF-compatível do lado-kernel é um ponto chave para obter o
desempenho bom.

Uma diferença arquitetural importante entre BPF e NPF é a escolha de um buffer

circular como o buffer do kernel. Nossa execução do buffer circular foi otimizada para
copiar blocos de pacotes no momento. Este mecanismo é mais difícil de controlar
porque a cópia de dados não tem seu tamanho inalterado por muito tempo (o libpcap usa
o mesmo tamanho para o buffer do kernel e do usuário, 32KB) e porque a quantidade
dos bytes copiados e atualizados ao transferir dados do espaço do kernel ao espaço do
usuário em vez de faze-lo em seguida. Certamente, o processo de cópia (começado no
nível de usuário) livra a parcela do buffer transferido já que a parcela da captação do
kernel pode a interromper, desde que funcione em uma prioridade mais elevada e nele
poderá monopolizar a toda hora o processador central. Nossa execução do buffer
permite que toda a memória seja utilizada para armazenar estouros de rede, quando um
par de buffer alternando (Assim como BPF) permitirem que somente a metade da
memória seja usada.

O buffer inteiro do kernell é copiado geralmente por meio de um único read(), assim
diminuindo o número de chamadas do sistema e conseqüentemente o número de
interrupções de contexto entre o usuário e a modalidade do kernel. Desde que um
interruptor de contexto requeira conservar o estado da tarefa (o descritor e a tarefa do
processador central indicam o segmento, os bytes de aproximadamente algumas
centenas), transferências grandes diminuem as despesas gerais do processo. Entretanto
um buffer demasiado grande do usuário não traz nenhuma vantagem porque as despesas
gerais do interruptor de contexto se tornam insignificantes quando a memória alocada
aumentar linearmente.

6
 O buffer do kernel do WinPcap é maior (1MB) do que o do BPF. Um buffer
pequeno penaliza a captura de processo especialmente nos casos em que a aplicação não
pode ler tão rapidamente quanto as captações do driver em um intervalo limitado de
tempo. Tal situação é comum quando os dados têm que ser transferidos ao disco ou
quando a rede tem o tráfego de rajadas. E vice-versa, o buffer de usuário é menor e seu
valor default é de 256KB. Ambos kernel e buffer de usuário podem ser mudado em
tempo de execução. O tamanho do buffer de usuário é muito importante porque
determina a quantidade máxima de dados que podem ser copiados do espaço do kernel
ao espaço do usuário dentro de uma única chamada ao sistema. No outro handle, nós
observamos que também a quantidade mínima de dados que podem ser copiada em uma
única chamada é extremamente importante. Na presença de um valor grande para esta
variável, o kernell espera a chegada de diversos pacotes antes de copiar os dados ao
usuário. Isto garante um número baixo de chamadas ao sistema, baixo o uso do
processador, que é um ajuste bom para aplicações como sniffers. No outro handle, um
valor pequeno significa que o kernel copa os pacotes assim que a aplicação estiver
pronta para os receber. Isto é excelente para aplicações de tempo real (como, para o
exemplo, um redirecionador ARP) que necessita de melhor segurança do kernel. A
maioria dos drivers de captura existentes tem um comportamento de estática que
privilegia um dos dois aspectos. No outro handle, NPF é completamente configurável e
permite que os usuários escolham entre a melhor eficiência e a melhor segurança (ou
algum comportamento intermediário). WinPcap inclui um par de chamadas ao sistema
que podem ser usadas para ajustar ambos os intervalos de parada depois que a leitura
expirar e a quantidade mínima de dados que podem ser transferidos à aplicação. Os
pacotes são copiados quando a quantidade mínima de dados está disponível ou o
intervalo de parada lido expirou. Por default, o intervalo de parada é 1 segundo e a
quantidade mínima de dados é 16K. Esta potencialidade é chamada frequentemente
"delayed write”.

Na memória geral as cópias têm que ser mantidas o mais baixo por causa de suas
despesas gerais. WinPcap tem as mesmas despesas gerais da cópia do libpcap/BPF
original e os pacotes são copiados duas vezes (do driver da rede ao kernel, então ao
espaço do usuário). Além disso, o filtramento é executado quando o pacote está ainda
na memória do driver de rede, assim evitando toda a cópia de pacotes não conformantes
em uma maneira similar como a função do bpf_tap() do DEB .

7
Figura 2.1 – Arquitetura do Winpcap

8
3. Exemplos
Abaixo exemplos de dois pequenos programas que utilizam as funcionalidades da
biblioteca WinPcap:

3.1 . SMP

#include <stdlib.h>
#include <stdio.h>

#include <pcap.h>

main(int argc, char **argv)

{
pcap_if_t *alldevs, *d;
pcap_t *fp;
u_int inum, i=0;
char errbuf[PCAP_ERRBUF_SIZE];
int res;
struct pcap_pkthdr *header;
u_char *pkt_data;
struct pcap_pkthdr old;

char a[11];

printf("SMP_1. (Copyright 2003 Gianluca Varenni - NetGroup, Politecnico di Torino)\n");

printf("\nThis program tests the WinPcap kernel driver on SMP machines.\n");
printf("The program tests that timestamps on the captured packets are consistent,\n");
printf("and that the caplen is equal to the packet length.\n");
printf("If there is an error, it will print out a message saying \"Inconsistent XXX\"\n");

if (pcap_findalldevs_ex(PCAP_SRC_IF_STRING, NULL, &alldevs, errbuf) == -1)

{
fprintf(stderr,"Error in pcap_findalldevs: %s\n", errbuf);
exit(1);
}

/* Print the list */

for(d=alldevs; d; d=d->next)
{
printf("%d. %s", ++i, d->name);
if (d->description)
printf(" (%s)\n", d->description);
else
printf(" (No description available)\n");
}

if(i==0)
{
printf("\nNo interfaces found! Make sure WinPcap is installed.\n");
return -1;
}

printf("Enter the interface number (1-%d):",i);

9
 scanf("%d", &inum);

if(inum < 1 || inum > i)

{
printf("\nInterface number out of range.\n");
/* Free the device list */
pcap_freealldevs(alldevs);
return -1;
}

/* Jump to the selected adapter */

for(d=alldevs, i=0; i< inum-1 ;d=d->next, i++);

/* Open the device */

if ( (fp= pcap_open(d->name, 65536, PCAP_OPENFLAG_PROMISCUOUS, 1000, NULL,
errbuf) ) == NULL)
{
fprintf(stderr,"\nUnable to open the adapter. %s is not supported by WinPcap\n", d-
>name);
/* Free the device list */
pcap_freealldevs(alldevs);
return -1;
}

old.ts.tv_sec=0;
old.ts.tv_usec=0;

/* Read the packets */

while((res = pcap_next_ex( fp, &header, &pkt_data)) >= 0){

if(res == 0)
continue;

//check that caplen is equal to packet length

if (header->caplen!=header->len)
printf("Inconsistent header: CapLen %d\t Len %d\n",header->caplen,header-
>len);

//check that timestamps always grow

if ( old.ts.tv_sec > header->ts.tv_sec || (old.ts.tv_sec == header->ts.tv_sec &&
old.ts.tv_usec > header->ts.tv_usec))
printf("Inconsistent Timestamps! Old was %d.%.06d - New is
%d.%.06d\n",old.ts.tv_sec,old.ts.tv_usec, header->ts.tv_sec,header->ts.tv_usec);

old=*header;

if(res == -1){
printf("Error reading the packets: %s\n", pcap_geterr(fp));
return -1;
}

scanf("%s",a);

return 0;
}

10
3.2 . Kdump

#include <stdlib.h>
#include <stdio.h>

#include <pcap.h>

#error At the moment the kernel dump feature is not supported in the driver

main(int argc, char **argv) {

pcap_if_t *alldevs, *d;

pcap_t *fp;
u_int inum, i=0;
char errbuf[PCAP_ERRBUF_SIZE];

printf("kdump: saves the network traffic to file using WinPcap kernel-level dump faeature.\n");
printf("\t Usage: %s [adapter] | dump_file_name max_size max_packs\n", argv[0]);
printf("\t Where: max_size is the maximum size that the dump file will reach (0 means no
limit)\n");
printf("\t Where: max_packs is the maximum number of packets that will be saved (0 means no
limit)\n\n");

if(argc < 5){

/* The user didn't provide a packet source: Retrieve the device list */
if (pcap_findalldevs(&alldevs, errbuf) == -1)
{
fprintf(stderr,"Error in pcap_findalldevs: %s\n", errbuf);
exit(1);
}

/* Print the list */

for(d=alldevs; d; d=d->next)
{
printf("%d. %s", ++i, d->name);
if (d->description)
printf(" (%s)\n", d->description);
else
printf(" (No description available)\n");
}

if(i==0)
{
printf("\nNo interfaces found! Make sure WinPcap is installed.\n");
return -1;
}

printf("Enter the interface number (1-%d):",i);

scanf("%d", &inum);

if(inum < 1 || inum > i)

11
 {
printf("\nInterface number out of range.\n");
/* Free the device list */
return -1;
}

/* Jump to the selected adapter */

for(d=alldevs, i=0; i< inum-1 ;d=d->next, i++);

/* Open the device */

if ( (fp = pcap_open_live(d->name, 100, 1, 20, errbuf) ) == NULL)
{
fprintf(stderr,"\nError opening adapter\n");
return -1;
}

/* Free the device list */

pcap_freealldevs(alldevs);

/* Start the dump */

if(pcap_live_dump(fp, argv[1], atoi(argv[2]), atoi(argv[3]))==-1){
printf("Unable to start the dump, %s\n", pcap_geterr(fp));
return -1;
}
}
else{

/* Open the device */

if ( (fp= pcap_open_live(argv[1], 100, 1, 20, errbuf) ) == NULL)
{
fprintf(stderr,"\nError opening adapter\n");
return -1;
}

/* Start the dump */

if(pcap_live_dump(fp, argv[0], atoi(argv[1]), atoi(argv[2]))==-1){
printf("Unable to start the dump, %s\n", pcap_geterr(fp));
return -1;
}
}

/* Wait until the dump finishes, i.e. when max_size or max_packs is reached*/
pcap_live_dump_ended(fp, TRUE);

/* Close the adapter, so that the file is correctly flushed */

pcap_close(fp); return 0 }

12
4. Ferramentas

4.1. Ethereal

Ethereal é um analisador/monitor de rede para Unix/Linux. Permite que você

examine dados de uma rede em tempo real ou de um segmento específico captado e
gravado em disco. Você pode interativamente "navegar" pelos dados da captação, obter
um sumário de observação e detalhes de cada pacote recebido/gravado... Excelente para
análise de problemas e diagnóstico.

4.2. IM Sniffer

Intercepta e decodifica todo o tráfego de mensagem imediato recebido pelo

computador. Possui bom desempenho e descrição da mensagem em tempo real. As
conversações podem ser vistas imediatamente ou salvas para uma análise mais
posterior.

13
5. Referências
[1] Fulvio Risso, Loris Degioanni, An Architecture for High Performance Network
Analysis, Proceedings of the 6th IEEE Symposium on Computers and Communications
(ISCC 2001), Hammamet, Tunisia, July 2001.
[2] Loris Degioanni, Development of an Architecture for Packet Capture and Network
Traffic Analysis, Graduation Thesis, Politecnico Di Torino (Turin, Italy, Mar. 2000).
[3] TANEMBAUM, A.S. Redes de Computadores. 4 edição. Editora
Campus.2003.
[4] WinPcap. Disponível por www em http://www.winpcap.com
(28/04/06).

14