Fontes:

http://site.grenfell.com.br/capturando-trafego-de-rede-com-tcpdump-parte-1-basico/

http://site.grenfell.com.br/capturando-trafego-de-rede-com-tcpdump-parte-2-filtros/

http://www.itnerante.com.br/profiles/blogs/an-lise-de-tr-fego-tcpdump-decifrando-a-sa-da-do-tcpdump

http://www.kernelhacking.com/rodrigo/docs/Tcpdump.pdf

https://danielmiessler.com/study/tcpdump/

http://www.rationallyparanoid.com/articles/tcpdump.html

https://www.comparitech.com/net-admin/tcpdump-cheat-sheet/

https://cdn.comparitech.com/wp-content/uploads/2019/06/tcpdump-cheat-sheet-1.pdf

Capturando trafego de rede com TCPDUMP – Parte 1 – Basico

Padrão | Postado em 28 de maio de 2013 by grenfell

O tcpdump é um sniffer de rede muito comum em sistemas *nix, a função de um sniffer de rede é basicamente capturar os pacotes de rede que estão chegando e saindo de alguma interface a fim de prover alguma analise.

Com o tcpdump é possível inserir diversos filtros para captura, bem como usar ou não resolução de nomes/ip, limitar o tamanho da captura e ainda exportar para um arquivo esta captura.

Com o arquivo de captura em mãos é possível analisar ele melhor em algum aplicativo gráfico (como o wireshark) ou ainda reproduzir a captura com o tcpreplay.

capturar interface eth0 (-i)

Para parar o sniffer use o bom e velho ctrl + c

capturar todas as interfaces (-i any)

capturar sem resolução de nomes (-n)

capturar sem resolução de nome de portas (exemplo aparecer porta 80 ao invez de aparecer http) (-nn)

com mais detalhes (-v)

com ainda mais detalhes (-vv)

Exibindo o pacote em Hexadecimal (-x)

Exibindo o pacote em Hexadecimal e ASCII (-X)

Exibindo o pacote apenas em ASCII

Limitando a captura a 10 pacotes (-c)

Sem mostrar tempo

Mostrando tempo em forma de timestamp não formatado

Mostrando o tempo em timestamp delta (diferença entre eles)

Mostrando o tempo com data e hora local

Limitando o tamanho do pacote capturado a 100 bytes (-s 100)

uma observação sutil, a janela padrão de captura é de 96 bytes

Tirando o limite do tamanho do pacote a capturar (-s 0)

Salvar a captura para um arquivo (-w)

Como a janela de captura padrão é de 96 bytes, o ideal é capturar sem limite, principalmente se for analisar depois.

Ler arquivo de captura (-r)

Por enquanto é só, em breve irei publicar o parte 2 – filtros!

Capturando trafego de rede com TCPDUMP – Parte 2 – Filtros

Padrão | Postado em 3 de junho de 2013 by grenfell

Falando um pouco mais de TCPDUMP, vamos usar agora os filtros!

A função dos filtros como o nome diz é filtrar o trafego a ser capturado, podemos filtrar ele por um monte de parâmetros diferentes como ip origem, destino, protocolo, porta, flags especificas dentro do protocolo, etc.

Bom vamos a alguns exemplos

Filtrando tudo que esteja relacionado ao ip 10.0.0.1

Somente quando a origem for 10.0.0.1

Somente quando o destino for 10.0.0.1

Somente porta 22

somente porta destino 22

Outros operadores que podemos usar para combinar :

Ether – especifica mac address

Qualquer comunicação com o mac 11:22:33:44:55:66

Comunicação com o mac origem aa:bb:cc:dd:ee:ff

Pacotes com o mac destino 1a:2b:3c:4d:5e:6f

Net – especifica uma rede inteira

Qualquer pacote relacionado a rede 172.16.0.0/24

Pacotes com a rede origem 172.16.0.0/24 (detalhe, especificando a mascara)

Rede destino 10.0.0.0/8

Port – especifica uma porta, independente de ser tcp ou udp

Qualquer comunicação com a porta 80

Comunicação apenas com destino a porta 443

Apenas origem a porta 22 TCP (SSH)

Apenas com destino a porta 53 UDP (consulta DNS)

Portrange – define um range de portas, pode usar os mesmos filtros do port para tcp, udp, origem e destino

Comunicação nas portas entre 1 e 1024

ip proto

Especifica qual protocolo acima da camada ip o filtro irá atuar. E necessário passar como parâmetro o código do protocolo. É possível ver uma lista de protocolos lendo o arquivo /etc/protocols

Protocolo 47 (GRE – usado em alguns tipos de vpn)

Alguns protocolos não é necessário passar desta forma, pois o tcpdump já os conhece, são eles : icmp, icmp6, igmp, igrp, pim, ah, esp, vrrp, udp, e tcp.

Vendo os pacotes do vrrp

pacotes igmp

Combinando!

Como vimos podemos usar SRC (para origem) e DST (para destino) nas expressão usada como filtro. Além disto podemos combinar elas usando AND (e) e OR (ou). Detalhe que precisamos usar o operador quando combinamos dois ou mais parâmetros do mesmo tipo (exemplo 2 ips ou 2 portas)

Exemplo:

Ip origem 10.0.0.1 e destino 12.0.0.2

Ip origem 10.0.0.1 e destino 12.0.0.2 e porta 22

Destino ao ip 10.0.3.1 na porta 22/TCP(ssh) ou na 53/UDP (dns)

Destino o ip 200.0.0.1 e porta 80/TCP(http) ou 443/TCP(https)

Por hora é só

em breve vou escrever um sobre filtros com flags especificar!

Análise de Tráfego - TCPDump (Decifrando a saída do TCPDump)

• Postado por Lhugo Júnior em 17 julho 2012 às 0:50
• Exibir blog

Oi galera, mais uma vez aqui fazendo um Post. Desta vez irei falar sobre a saída do TCPDump.

Eu escolhi falar neste momento no TCPDump, porque o concurso da PF está cada vez mais próximo e comparando com o WireShark a saída do TCPDump é muito mais difícil de entender.

Para você compreender totalmente este Post é necessário que você tenha um bom conhecimento na arquitetura TCP/IP e conheça o funcionamento de protocolos como o TCP, IP, UDP, e etc. Não irei me aprofundar explicando como estes protocolos funcionam, para estudar eles aconselho a assistir as aulas do Professor Walter e a ler bastante sobre o assunto e também existe o memorex de análise de tráfego feito pelo Paulo Marcelo.

Hoje só irei abordar o TCP e o Three Way HandShake

Começando...

Entendendo o Formato

Ex. 1

09:32:43:910000 192.168.200.2.1173 > 192.168.200.30.21: S 62697789:62697789(0) win 512

• 09:32:43:910000 Esse é o time stamp, ou carimbo do pacote. Mostra 2 dígitos para horas, 2 dígitos para o minuto, 2 dígitos para o segundo e 6 dígitos para fração de segundos.
• 192.168.200.2 Mostra o IP de origem do pacote. As vezes pode aparecer a resolução do nome e ao invés de vir o IP irá vir o nome de domínio. Isso depende se opção do TCPDump –n está ou não habilitada.
• 1173 Essa é a porta de origem.
• > Somente indica a direção do fluxo. ORIGEM > DESTINO.
• 192.168.200.30 Esse é o IP de destino.
• 21 Esse indica a porta de destino
• SEsse indica que a flag SYN do TCP.

• S é a flag SYN.
• P é a flag PUSH
• R é a flah RESET
• ack é a flag que reconhece os dados recebidos.
• urg é a flag que indica que existe um dado urgente. Que deve ter mais prioridade sobre outros dados.
• . (ponto) indica que não tem flag setada.
• 62697789:62697789(0) Esse é o NUMERO DE SEQUENCIA INICIAL:NUMERO DE SEQUENCIA FINAL (QUANTIDADE DE BYTES).
• win 512 É o tamanho do buffer para receber dados que o IP 192.168.200.2 está aceitando em bytes. (Tamanho da Janela).

Ex. 2

client.com.38060 > server.com.21: S 3774957990:3774957990(0) win 8760 <mss 1460> (DF)

server.com.21> client.com.38060: S 2009600000:2009600000(0) ack 3774957991 win 1024 <mss 1460>

client.com.38060 > server.com.21: .ack 1 win 8760 (DF)

client.com.38060 > server.com.21: P 1:28(27) ack 1 win 8760 (DF)

Para facilitar, foi removido o time stamp. E agora só irei falar o que aparece de diferente.

Este conjunto de pacotes está revelando que a o início de uma conexão TCP, usando a porta 21 (FTP controle). E podemos ver claramente o Three-way-handshake do TCP.

• 3774957990:3774957990(0) Número de sequência. Podemos perceber que este número de sequência inicial e final é o mesmo, isso acontece porque nenhum dado está sendo transmitido. Não existe payload no segmento TCP.
• <mss 1460> Isso indica o Maximum Segmet Size ou tamanho máximo do segmento. O MSS é o tamanho máximo da carga do TCP. MSS não inclui nenhum tamanho dos cabeçalhos TCP nem IP. É bom também vocês saberem o que é MTU (MAXIMUM TRANSFER UNIT). O MTU é o tamanho máximo do pacote, que pode ser calculada sendo o MSS + Tamanho dos cabeçalhos TCP e IP. Considerando que normalmente os cabeçalhos TCP e IP possuem 20 bytes cada, então para esse pacote podemos considerar que o MTU = MSS + 20 (TCP) + 20 (IP) = 1500.
• (DF) Flag que indica que este pacote não aceita fragmentação.
• ack 3774957991 Indica que confirmou os pacotes com sequence number 3774957990 e agora o próximo pacote que esperar receber é o que tem sequence number 3774957991

Nos últimos dois pacotes vocês irão perceber que o sequence number irá mudar. Ou seja irá começar do 1. Isso acontece porque o TCPDump utiliza o sequence number relativo, para facilitar na leitura.

• ack 1 Confirma o rebimento do ultimo pacote e espera receber o próximo pacote de sequence number relativo 1 do server.com
• P Indica que a flag PUSH está ligada, essa flag fala para enviar o pacote diretamente para a aplicação.
• 1:28(27) Sequence numbers que está enviando. Indica que tem uma carga (payload) de 27 bytes sendo enviado. Está enviando os sequence number de 1 a 28.

Galera por hoje é só. Se possuir algum erro posta aí.

Talvez mais para frente eu coloque mais exemplos. Quem sabe abordando outros protocolos. Depois também posso postar referências e livros para aprender a fazer análise de tráfego. Se tiverem recomendações ou pedidos ou dúvidas postem aí, ajudo na medida do possível.

Manual do tcpdump em Português

TCPDUMP(1) TCPDUMP(1)

NOME

tcpdump - captura o tráfego em uma rede

SINOPSE

tcpdump [ -adeflnNOpqRStvxX ] [ -c contagem ] [ -F arquivo ] [ -i interface ] [ -m módulo] [ -r arquivo ] [ -s tamanho ] [ -T tipo ] [ -w arquivo ] [ -E algo:secret ] [ expressão ]

DESCRIÇÃO

Tcpdump imprime a saída dos cabeçalhos dos pacotes na interface de rede que combinam com a expressão booleana.

No SunOS com nit ou bpf: Para rodar tcpdump você necessita ter permissão de acesso a /dev/nit ou /dev/bpf*.

No Solaris com dlpi: Você precisa ter acesso de leitura/escrita ao pseudo dispositivo de rede, por exemplo /dev/le.

No HP-UX com dlpi: Você necessita ser root ou ter este instalado com setuid para root.

No IRIS com snoop: Você necessita ser root ou ter este instalado com setuid para root.

No Linux: Você necessita ser root ou ter este instalado com setuid para root.

No Ultrix e Digital UNIX: Somente o super-usuário tem permissão de utilizar o modo de operação promíscuo usando pfconfig(8), qualquer usuário pode rodar o tcpdump.

No BSD: Você necessita ter acesso de leitura em /dev/bpf*.

OPÇÕES:

-a Espera para converter endereços de rede e broadcast para nomes.

-c Sai após receber contagem de pacotes.

-d Captura os pacotes compilados com o código do pacote em um formato humanamente legível para a saída padrão e sai.

-dd Captura os pacotes com o código do pacote como um fragmento de programa em C.

-ddd Captura os pacotes com o código do pacote como números decimais (precedidos de um contador).

-e Imprime a camada de link do cabeçalho na linha capturada.

-E Use algo:secreto para decriptar pacotes IPsec ESP.

Algoritmos costumam ser des-cbc, 3des-cbc, blowfish-cbc, rc3-cbc, cast128-cbc, ou nenhum. O padrão é des-cbc.

A habilidade de descriptar pacotes só estará presente se o tcpdump for compilado com suporte a criptografia habilitado. secreto é o texto ASCII para a chave ESP secreta.

Nós não tentaremos um valor binário arbitrário neste momento.

A opção assume a RFC2406 do ESP, não a RFC1827 também do ESP.

A opção é somente para propósitos de depuração, e o uso desta opção com uma chave secreta TRULY é desencorajada.

Pela apresentação da chave secreta do IPsec na linha de comando você consegue deixar isto visível para outros, via ps(1) e em outras ocasiões.

-f Imprime a saída dos endereços internet numéricamente no lugar de simbólicamente (essa opção tenta descobrir sérios problemas em servidores YP utilizando Sun -- usualmente causa um loop eterno na conversão de não-locais números internet).

-F Utiliza o arquivo para a entrada de um filtro de expressão.

Qualquer expressão adicional passada via linha de comando é ignorada.

-i Escute na interface. Se não especificado o tcpdump irá procurar a lista de interfaces do sistema, interfaces ativas (excluindo a de loopback).

Em sistemas Linux com kernels 2.2 ou superiores, um argumento ``any'' para interfaces pode ser usado para capturar pacotes de todas as interfaces.

Note que as capturas em ``any'' (todos) os dispositivos não poderá ser feita no modo promíscuo.

-l Deixe a linha de saída "bufferizada". Usualmente se você quizer ver os dados enquanto são capturados.

Ex: ``tcpdump -l | tee dat'' ou ``tcpdump -l > dat & tail -f dat''.

-n Não converter endereços (Ex: endereços de hosts e números de portas, etc) para nomes.

-N Não imprime a qualificação do domínio dos nomes de host. Ex: se você passar esta flag para o tcpdump, ele imprimirá ``nic'' ao invés de ``nic.ddn.mil''.

-m Carrega as definições do módulo SMI MIB do arquivo módulo. Esta opção pode ser usada em diversas vezes para carregar severos módulos MIB no tcpdump.

-O Não execute o otimizador de códigos de pacote. Isso usualmente só será utilizado se você suspeitar de uma falha no otimizador.

-p Não coloca a interface em modo promíscuo. Note que esta interface pode precisar entrar em modo promíscuo por alguma outra razão; então, `-p' não poderá ser usado como uma abreviação para `ether host {local-hw- addr} ou ether broadcast'.

-q Saída rápida (quieta?). Imprime menos informações do protocolo em saídas de linhas mais curtas.

-r Lê os pacotes do arquivo (isso é criado com a opção -w). A entrada padrão será utilizada se o arquivo for ``-''.

-s Sniffa tamanho de bytes de arquivo deste pacote.

O default é 68 (com SunOS's NIT, o mínimo é atualmente 96). 68 bytes é adequado para IP, ICMP, TCP e UDP porém pode truncar informações de protocolos de pacotes DNS e NFS (olhe na frente). Os pacotes serão truncados porque um tamanho limitado foi indicado e a saída será ``[|proto]'', onde proto é o nome do nível do protocolo onde a truncagem ocorreu.

Note que aumentar muito o tamanho pode causar uma delonga no tempo para processar estes pacotes e, efetivamente, diminuir a quantidade de pacotes capturados.

Isso pode causar perda de pacotes. Você deve limitar o tamanho dos pacotes para o menor possível onde você conseguirá obter a informação que lhe interessar. Coloque o tamanho em 0 para que o tcpdump capture os pacotes completos, independente dos seus tamanhos.

-T Força que os pacotes selecionados pela "expressão" sejam interpretados pelo tipo especificado. Atualmente, os tipos conhecidos são cnfp (Protocolo Cisco NetFlow), rpc (Chamadas de procedimento remotas), rtp (Protocolo de aplicações em tempo real), rtcp (Protocolo de controle de aplicações em tempo real), snmp (Protocolo simples de gerenciamento de redes), vat (Aplicação de Visual Audio), e wb (Placa Branca distribuída).

-R Assume que pacotes ESP/AH são baseados em especificações antigas (RFC1825 a RFC1829). Se especificado, o tcpdump não irá imprimir o campo de prevensão. No entanto, este não é um campo de versão na especificação do protocolo ESP/AH, portanto o tcpdump não poderá deduzir a versão do protocolo.

-S Imprimir o absoluto, em lugar do relativo, número de sequência TCP.

-t Não imprimir o timestamp na linha capturada.

-tt Imprimir um não formatado timestamp na linha capturada.

-v Detalhamento da saída (não muito). Por exemplo, o tempo de vida, identificação, tamanho total e opções do cabeçalho IP serão impressos. Também se habilita opções adicionais de checagem da integridade dos pacotes como verificação do checksum dos cabeçalhos IP e ICMP.

-vv Saída mais detalhada. Por exemplo, campos adicionais serão impressos em pacotes NFS de resposta.

-vvv Saída mais detalhada ainda. Por exemplo, as opções telnet SB ... SE serão impressas totalmente. Com -X as opções do telnet serão impressas em HEX muito bem.

-w Escreve os pacotes capturados no arquivo no lugar de selecioná-los e imprimí-los. Isso poderá ser impresso utilizando-se a opção -r. A saída padrão será utilizada se o arquivo for ``-''.

-x Imprime este pacote (menos seu cabeçalho de camada de link) em hexadecimal.

Tamanho em bytes será impresso (opção -s).

-X Se imprime em hexa, imprime em ASCII também. Se a opção -x também for selecionada, o pacote será impresso em hexa/ascii.

Isso é muito útil para analizar novos protocolos. Se a opção -x não estiver selecionada, algumas partes de alguns pacotes serão impressas em hexa/ascii.

expressão

Seleciona quais pacotes serão capturados. Se nenhuma expressão for passada, todos os pacotes da rede serão capturados.

Se informada, apenas os pacotes que tiverem a expressão como sendo verdadeira (combinarem com a expressão) serão capturados.

A expressão consiste em uma ou mais primitivas.

Primitivas usualmente consistem em um identificador (nome ou número) precedidas de um ou mais qualificadores. Existem 3 diferentes qualificadores: type indica qual identificador (nome ou número) ele se refere. Os tipos possíveis são: host, net e port.

Exemplos:

``host foo''

``net 128.3''

``port 20''

Se nenhum qualificador type for especificado, host será assumido.

dir indica a direção em que a transferência ocorrerá, para e/ou do identificador. As direções possíveis são src, dst, src or dst e src and dst

Exemplos:

``src foo''

``dst net 128.3''

''src or dst port ftp-data''

Se nenhum qualificador dir for especificado, src or dst será assumido. Para camadas de link ``null'' (Ex: protocolos de ponto a ponto como o slip) os qualificadores de entrada e saída devem ser utilizados para especificar a direção desejada.

proto Qualificador restrito a estipular um tipo particular de protocolo. As opções existentes de protocolo são:

ether, fddi, tr, ip, ip6, arp, rarp, decnet, tcp e udp.

Ex:

``ether src foo''

``arp net 128.3''

``tcp port 21''

Se não estipulado, todos os protocolos existentes em opção serão assumidos.

Ex:

``src foo'' inclui

``(ip or arp or rarp) src foo''

``net bar'' inclui

``(ip or arp or rarp) net bar'' e

``port 53'' inclui

``(tcp or udp) port 53''.

[`fddi' é atualmente um apelido para `ether'; isso seria idêntico a mensionar ``o nível de link de dados usado nesta específica interface de rede.''

Cabeçalhos FDDI possuem campos iguais ao Ethernet, de endereços de origem e destino, e também tipo de pacotes, então você pode filtrar estes campos FDDI analogamente como você faz com estes campos Ethernet.

Cabeçalhos FDDI também contém outros campos, porém você não poderá especificá-los em uma expressão de filtro.

Similarmente, `tr' é um apelido para `ether'; o parágrafo anterior sobre os cabeçalhos FDDI também se aplica a cabeçalhos Token Ring.]

Em adição a isto, existe algumas outras diretivas especiais que não foram mencionadas: gateway, broadcast, less, greater e expressões aritméticas. Todas elas serão descritas mais adiante.

Expressões de filtragem mais complexas podem ser feitas utilizando-se expressões como and, or e not combinadas com as diretivas.

Ex:

``host foo and not port ftp and not port ftp-data''.

Para facilitar, listas de qualificadores idênticos podem ser omitidas.

Ex:

``tcp dst port ftp or ftp-data or domain'' é exatamente o mesmo que:

``tcp dst port ftp or tcp dst port ftp-data or tcp dst port domain''.

Primitivas (diretivas) permitidas são:

dst host host

Verdadeiro se o campo de destino de pacotes IPv4/v6 for host, este pode ser endereço ou nome.

src host host

Verdadeiro se o campo de origem de pacotes IPv4/v6 for host. host host

Verdadeiro se o campo de origem ou destino de pacotes IPv4/v6 for host. Qualquer uma destas expressões de host podem ser precedidas por diretivas tais como ip, arp, rarp, ou ip6, assim:

ip host host

isso é o equivalente a:

ether proto ip and host host

Se host for um nome com múltiplos endereços IP, eles serão checados para a correlação.

ether dst ehost

Verdadeiro se o endereço de destino ethernet for ehost. Ehost pode ser um nome de /etc/ethers ou um número (veja ethers(3N) para o formato numérico).

ether src ehost

Verdadeiro se o endereço de origem ethernet for ethos.

ether host ehost

Verdadeiro se o endereço de origem ou de destino ethernet for ehost.

gateway host

Verdadeiro se o host usado no pacote for um gateway. Ex: o endereço de origem ou destino ethernet seja um host diferente do endereço de origem ou destino IP.

Host precisa ser um nome e ser encontrado tanto em /etc/hosts quanto /etc/ethers. (Uma expressão equivalente seria:

ether host ehost and not host host que poderia ser usada com nomes ethernet ou números para host / ehost.)

Esta syntax por enquanto não funciona com configurações IPv6.

dst net net

Verdadeiro se o endereço de destino IPv4/v6 do pacote for um número de rede. Net pode ser um nome de /etc/networks ou um número de rede (veja networks(4) para maiores detalhes).

src net net

Verdadeiro se o endereço de origem IPv4/v6 do pacote for um número de rede.

net net

Verdadeiro se o endereço de origem ou destino IPv4/v6 do pacote for um número de rede.

net net mask mask

Verdadeiro se o endereço IP combinar com a rede de mascará especificada. Pode ser qualificada com src ou dst. Esta syntax também não foi implementada para redes IPv6.

net net/len

Verdadeiro se o endereço IPv4/v6 combinar com a rede que possua netmask len bits. Pode ser qualificada com src ou dst.

dst port port

Verdadeiro se o pacote for ip/tcp, ip/udp, ip6/tcp ou ip6/udp e sua porta de destino seja port.

A porta pode ser um número ou um nome usado em /etc/services (veja tcp(4P) e udp(4P)).

Se um nome for usado, tanto o número da porta quanto o protocolo serão checados.

Se um número ou um nome ambíguo for utilizado, somente o número da porta será checado.

Ex:

dst port 513

Irá imprimir tanto tcp/login quanto udp/who

e

port domain

Irá imprimir tanto tcp/domain quanto udp/domain

src port port

Verdadeiro se o pacote tiver a porta de origem port.

port port

Verdadeiro se a porta de origem ou de destino do pacote for port. Todas as expressões de porta anteriores podem ser precedidas com diretivas tcp ou udp, assim:

tcp src port port

Irá capturar apenas pacotes tcp com porta de origem port.

less length

Verdadeiro se o pacote tiver um tamanho menor ou igual a length. Isso seria o equivalente a:

len <= length.

greater length

Verdadeiro se o pacote tiver um tamanho maior ou igual a length. Isso seria o equivalente a:

len >= length.

ip proto protocol

Verdadeiro se o pacote for um pacote IP (veja ip(4P)) com protocolo de tipo protocol.

Protocol pode ser um número ou um dos nomes: icmp, icmp6, igmp, igrp, pim, ah, esp, udp ou tcp.

Note que os identificadores tcp, udp e icmp também são diretivas que podem ser passadas via backslash (l), isso seria no C-Shell.

Perceba que esta primitiva não observa a regra de protocolo do cabeçalho.

ip6 proto protocol

Verdadeiro se o pacote for um pacote IPv6 com protocolo de tipo protocol.

Observe que esta primitiva não observa a regra de protocolo do cabeçalho.

ip6 protochain protocol

Verdadeiro se o pacote for um pacote IPv6, e conter um cabeçalho de protocolo com tipo protocol na regra de protocolo do cabeçalho.

Por exemplo:

ip6 protochain 6

combina com qualquer pacote IPv6 com o protocolo TCP definido na regra do cabeçalho que especifica o protocolo.

O pacote pode conter, por exemplo, cabeçalho de autenticação, roteamento, hop-by-hop, tanto IPv6 quanto TCP. O código BPF emitido por esta primitiva é complexo e não será otimizado pelo otimizador BPF do tcpdump, porque isto ficaria muito lento.

ip protochain protocol

Equivalente ao ip6 protochain protocol, porém este é válido para IPv4.

ether broadcast

Verdadeiro se o pacote for um pacote ethernet de broadcast. A diretiva ether é opcional.

ip broadcast

Verdadeiro se o pacote for um pacote de broadcast IP. Isso irá checar tanto por tudo-zero quanto tudo-um como convenção para broadcast, e olhará para a máscara de subrede local.

ether multicast

Verdadeiro se o pacote for um pacote ethernet de multicast. A diretiva ether é opcional.

Isto é uma abreviação de ``ether[0] & 1 != 0''.

ip multicast

Verdadeiro se o pacote for um pacote IP multicast.

ip6 multicast

Verdadeiro se o pacote for um pacote IPv6 multicast.

ether proto protocol

Verdadeiro se o pacote for um pacote ethernet com tipo protocol.

Protocol pode ser um número ou um dos seguintes nomes:

ip, ip6, arp, rarp, atalk, aarp, dec-net, sca, lat, mopdl, moprc, ou iso.

Observe que estes identificadores também são diretivas que podem ser passados via backslash (l).

[ No caso do FDDI (ex: ``fddi protocol arp''), a identificação do protocolo vêm do cabeçalho 802.2 Logical Link Control (LLC), e isto poderá usualmente estar no topo da camada do cabeçalho FDDI.

O tcpdump assumirá, enquanto filtra o identificador de protocolo, que todos os pacotes FDDI incluem um cabeçalho LLC e que este cabeçalho estará no formato SNAP. O mesmo se aplica ao Token Ring.]

decnet src host

Verdadeiro se o endereço de origem DECNET for host, isto poderá ser um endereço na forma ``10.123'', ou um nome de host DECNET.

[O suporte a nomes de host DECNET só está disponível em sistemas Ultrix configurados para rodar DECNET.]

decnet dst host

Verdadeiro se o endereço de destino DECNET for host.

decnet host host

Verdadeiro se o endereço de destino ou de origem DECNET for host.

ip, ip6, arp, rarp, atalk, aarp, decnet, iso

Abreviações para:

ether proto p

onde p é um dos protocolos mencionados anteriormente.

lat, moprc, mopdl

Abreviações para:

ether proto p

onde p é um dos protocolos mencionados anteriormente.

Perceba que o tcpdump atualmente não possui "know how" para estes protocolos.

vlan [vlan_id]

Verdadeiro se o pacote for um pacote VLAN IEEE 802.1Q Se [vlan_id] for especificado, somente será verdadeiro o pacote que obedeça a especificação [vlan_id].

Observe que esta é a primeira diretiva vlan encontrada nas mudanças em expressão com offsets de decodificação para definir que este pacote é um pacote VLAN.

tcp, udp, icmp

Abreviações para:

ip proto p or ip6 proto p

onde p é um dos protocolos mencionados anteriormente.

iso proto protocol

Verdadeiro se o pacote for um pacote OSI com tipo de protocolo protocol. Protocol pode ser um número ou um dos seguintes nomes: clnp, esis ou isis.

clnp, esis, isis

Abreviações para:

iso proto p

onde p é um dos protocolos mencionados anteriormente. Observe que o tcpdump faz um trabalho incompleto para selecionar estes protocolos.

expr relop expr

Verdadeiro se a relação holds, onde relop é um dos seguintes: >, <, >=, <=, =, !=, e expr é uma expressão aritmética composta por uma constante inteira (expressa na syntax padrão da linguagem C), os operadores binários normais, a saber: +, -, *, /, &, |, um operador de tamanho e um pacote especial de dados acessórios.

Para acessar o interior dos dados de um pacote, use a seguinte syntax:

proto [ expr : size ]

Proto é um dos seguintes:

ether, fddi, tr, ip, arp, rarp, tcp, udp, icmp ou ip6, e indica a camada de protocolo para a operação de índice. Observe que tcp, udp e outros protocolos de camada mais alta, somente se aplicam ao IPv4, não ao IPv6 (isso será corrigido no futuro).

O final do byte, relativo a camada indicada do protocolo, é passado em expr.

Size (tamanho) é opcional e indica o número de bytes no campo de interesse; este pode ser:

one, two ou four, sendo o padrão one.

O operador de tamanho, indicado pela diretiva len, informa o tamanho do pacote.

Por exemplo:

``ether[0] & 1 != 0''

Captura todo o tráfego multicast.

A expressão:

``ip[0] & 0xf != 5''

Captura todos os pacotes IP com opções.

A expressão:

``ip[6:2] & 0x1fff = 0''

Captura somente datagramas não fragmentados e fragmentos zero dos datagramas fragmentados.

Esta checagem pode ser expecificamente aplicada para operações de índice em tcp e udp.

Então, tcp[0] sempre menciona o primeiro byte do cabeçalho TCP, e nunca o primeiro byte de um fragmento.

Diretivas podem ser combinadas usando-se:

Diretivas e operadores entre parênteses (parênteses são especiais para o Shell e serão interpretados).

Negação: (`!' ou `not').

Concatenação (e): (`&&' ou `and').

Alternação (ou): (`||' ou `or').

Negação deve ser precedida. Alternação e concatenação necessitam de precedência e associam esquerda com direita.

Se um identificador for passado sem uma diretiva, a mais recente diretiva será assumida.

Por exemplo:

not host vs and ace

será igual à:

not host vs and host ace

mas não pode ser confundido com:

not ( host vs or ace )

Argumentos de expressão podem ser passados ao tcpdump como um simples argumento, ou como múltiplos argumentos.

Geralmente, se a expressão contiver metacaracteres de SHELL, será mais fácil passar como um simples argumento entre aspas.

Múltiplos argumentos são concatenados com espaços antes de serem analizados.

EXEMPLOS

Para imprimir todos os pacotes vindos de ou para o departamento sundown tcpdump host sundown

Para imprimir o tráfego entre helios e hot ou ace:

tcpdump host helios and ( hot or ace )

Para imprimir todos os pacotes IP entre ace e qualquer host exceto helios:

tcpdump ip host ace and not helios

Para imprimir todo tráfego entre hosts locais e hosts em Berkeley:

tcpdump net ucb-ether

Para imprimir todo tráfego ftp para a internet através do gateway snup:

(Observe que a expressão está entre parênteses para prevenir que o shell interprete o que está entre parênteses)

tcpdump 'gateway snup and (port ftp or ftp-data)'

Para imprimir o tráfego para redes fora da rede local (se você for gateway para outra rede, esta regra pode não prever isto em sua rede local).

tcpdump ip and not net localnet

Para imprimir pacotes de início e final de conexões (SYN e FIN) TCP envolvendo hosts não-locais.

tcpdump 'tcp[13] & 3 != 0 and not src and dst net localnet'

Para imprimir pacotes IP maiores do que 576 bytes enviados através do gateway snup:

tcpdump 'gateway snup and ip[2:2] > 576'

Para imprimir pacotes de broadcast ou multicast IP que não estão sendo enviados via broadcast ou multicat ethernet

tcpdump 'ether[0] & 1 = 0 and ip[16] >= 224'

Para imprimir todos os pacotes ICMP que não sejam echo request/reply (não sejam ping's)

tcpdump 'icmp[0] != 8 and icmp[0] != 0'

SEE ALSO

traffic(1C), nit(4P), bpf(4), pcap(3)

AUTHORS

The original authors are:

Van Jacobson, Craig Leres and Steven McCanne, all of the Lawrence Berkeley National Laboratory, University of Cali- fornia, Berkeley, CA.

It is currently being maintained by tcpdump.org.

The current version is available via http:

http://www.tcpdump.org/

The original distribution is available via anonymous ftp:

ftp://ftp.ee.lbl.gov/tcpdump.tar.Z

IPv6/IPsec support is added by WIDE/KAME project. This program uses Eric Young's SSLeay library, under specific configuration.

http://www.tcpdump.org/

The original distribution is available via anonymous ftp:

ftp://ftp.ee.lbl.gov/tcpdump.tar.Z

IPv6/IPsec support is added by WIDE/KAME project. This program uses Eric Young's SSLeay library, under specific configuration.

BUGS

Please send problems, bugs, questions, desirable enhance- ments, etc. to:

tcpdump-workers@tcpdump.org

Please send source code contributions, etc. to:

patches@tcpdump.org

NIT doesn't let you watch your own outbound traffic, BPF will. We recommend that you use the latter.

On Linux systems with 2.0[.x] kernels:

packets on the loopback device will be seen twice;

packet filtering cannot be done in the kernel, so that all packets must be copied from the kernel in order to be filtered in user mode;

all of a packet, not just the part that's within the snapshot length, will be copied from the

kernel (the 2.0[.x] packet capture mechanism, if asked to copy only part of a packet to

userland, will not report the true length of the packet; this would cause most IP packets to

get an error from tcp- dump).

We recommend that you upgrade to a 2.2 or later kernel. Some attempt should be made to reassemble IP fragments or, at least to compute the right

length for the higher level protocol.

Name server inverse queries are not dumped correctly: the (empty) question section is

printed rather than real query in the answer section. Some believe that inverse queries are

themselves a bug and prefer to fix the program gener- ating them rather than tcpdump.

A packet trace that crosses a daylight savings time change will give skewed time stamps

(the time change is ignored).

Filter expressions that manipulate FDDI or Token Ring headers assume that all FDDI and

Token Ring packets are SNAP-encapsulated Ethernet packets. This is true for IP, ARP, and

DECNET Phase IV, but is not true for protocols such as ISO CLNS. Therefore, the filter

may inadvertently accept certain packets that do not properly match the fil- ter expression.

Filter expressions on fields other than those that manipu- late Token Ring headers will not

correctly handle source- routed Token Ring packets.

ip6 proto should chase header chain, but at this moment it does not. ip6 protochain is

supplied for this behavior.

Arithmetic expression against transport layer headers,

A packet trace that crosses a daylight savings time change will give skewed time stamps

(the time change is ignored).

Filter expressions that manipulate FDDI or Token Ring headers assume that all FDDI and

Token Ring packets are SNAP-encapsulated Ethernet packets. This is true for IP, ARP, and

DECNET Phase IV, but is not true for protocols such as ISO CLNS. Therefore, the filter

may inadvertently accept certain packets that do not properly match the fil- ter expression.

Filter expressions on fields other than those that manipu- late Token Ring headers will not

correctly handle source- routed Token Ring packets.

ip6 proto should chase header chain, but at this moment it does not. ip6 protochain is

supplied for this behavior.

Arithmetic expression against transport layer headers, like tcp[0], does not work against IPv6 packets. It only looks at IPv4 packets.

3 January 2001 TCPDUMP(1)

TRADUTOR:

Nome : Rodrigo Rubira Branco

Email : rodrigo@br.tcpdump.org

Site : http://www.br.tcpdump.org

Empresa: Firewalls Security (http://www.firewalls.com.br)

Nota do Tradutor: Agradeço a empresa Firewalls Security por ter me concedido tempo para trabalhar e auxiliar no projeto deste excelente packet sniffer, podendo contribuir de diversas formas para o mesmo, e cedendo espaço em seu servidor para armazenar um mirror completo do TCPDUMP. Percebam que a tradução do manual completo ainda não foi feita, e espero contar com a colaboração de todos para que o seja o mais rápido possível.

Obrigado!

A tcpdump Primer with Examples

Home » Study » A tcpdump Primer with Examples

• Options
• Basic Usage
• Examples
• Writing to a File
• Getting Creative
• Advanced

[ NOTE: For more primers like this, check out my tutorial series. ]

tcpdump is the premier network analysis tool for information securityprofessionals. Having a solid grasp of this über-powerful application is mandatory for anyone desiring a thorough understanding of TCP/IP. Many prefer to use higher level analysis tools such as EtherealWireshark, but I believe this to usually be a mistake.

In a discipline so dependent on a true understanding of concepts vs.rote learning, it’s important to stay fluent in the underlying mechanics of the TCP/IP suite. A thorough grasp of these protocols allows one to troubleshoot at a level far beyond the average analyst, but mastery of the protocols is only possible through continued exposure to them.

When using a tool that displays network traffic a more natural (raw) way the burden of analysis is placed directly on the human rather than the application. This approach cultivates continued and elevated understanding of the TCP/IP suite, and for this reason I stronglyadvocate using tcpdump instead of other tools whenever possible.

15:31:34.079416 IP (tos 0x0, ttl 64, id 20244, offset 0, flags [DF], proto: TCP (6), length: 60) source.35970 > dest.80: S, cksum 0x0ac1 (correct), 2647022145:2647022145(0) win 5840 0x0000: 4500 003c 4f14 4000 4006 7417 0afb 0257 E.. 0x0010: 4815 222a 8c82 0050 9dc6 5a41 0000 0000 H."*...P..ZA.... 0x0020: a002 16d0 0ac1 0000 0204 05b4 0402 080a ................ 0x0030: 14b4 1555 0000 0000 0103 0302

Options

Below are a few options (with examples) that will help you greatly when working with the tool. They’re easy to forget and/or confuse with other types of filters, i.e. ethereal, so hopefully this page can serve as a reference for you, as it does me.

First off, I like to add a few options to the tcpdump command itself, depending on what I’m looking at. The first of these is -n, which requests that names are not resolved, resulting in the IPs themselves always being displayed. The second is -X, which displays both hex and ascii content within the packet. The final one is -S, which changes the display of sequence numbers to absolute rather than relative. The idea there is that you can’t see weirdness in the sequence numbers if they’re being hidden from you. Remember, the advantage of usingtcpdump vs. another tool is getting manual interaction with the packets.

It’s also important to note that tcpdump only takes the first 68 96 bytes of data from a packet by default. If you would like to look at more, add the -s number option to the mix, where number is the number of bytes you want to capture. I recommend using 0 (zero) for a snaplength, which gets everything. Here’s a short list of the options I use most:

[ NOTE: All of the following come after tcpdump, for example: tcpdump -i any ]

• -i any : Listen on all interfaces just to see if you’re seeing any traffic.
• -i eth0 : Listen on the eth0 interface.
• -D : Show the list of available interfaces
• -n : Don’t resolve hostnames.
• -nn : Don’t resolve hostnames or port names.
• -q : Be less verbose (more quiet) with your output.
• -X : Show the packet’s contents in both hex and ASCII.
• -XX : Same as -X, but also shows the ethernet header.
• -v, -vv, -vvv : Increase the amount of packet information you get back.
• -c : Only get x number of packets and then stop.
• icmp : Only get ICMP packets.
• -s : Define the snaplength (size) of the capture in bytes. Use -s0to get everything, unless you are intentionally capturing less.
• -S : Print absolute sequence numbers.
• -e : Get the ethernet header as well.
• -q : Show less protocol information.
• -E : Decrypt IPSEC traffic by providing an encryption key.

[ The default snaplength as of tcpdump 4.0 has changed from 68 bytes to 96 bytes. While this will give you more of a packet to see, it still won’t get everything. Use -s 1514 to get full coverage ]

Basic Usage

So, based on the kind of traffic I’m looking for, I use a different combination of options to tcpdump, as can be seen below:

1. Basic communication // see the basics without many options
   1. # tcpdump -nS
2. Basic communication (very verbose) // see a good amount of traffic, with verbosity and no name help
   1. # tcpdump -nnvvS
3. A deeper look at the traffic // adds -X for payload but doesn’t grab any more of the packet
   1. # tcpdump -nnvvXS
4. Heavy packet viewing // the final “s” increases the snaplength, grabbing the whole packet
   1. # tcpdump -nnvvXSs 1514

Here’s a capture of exactly two (-c2) ICMP packets (a ping and pong) using some of the options described above. Notice how much we see about each packet.

hermes root # tcpdump -nnvXSs 0 -c2 icmp tcpdump: listening on eth0, link-type EN10MB (Ethernet), 23:11:10.370321 IP (tos 0x20, ttl 48, id 34859, offset 0, flags [none], length: 84) 69.254.213.43 > 72.21.34.42: icmp 64: echo request seq 0 0x0000: 4520 0054 882b 0000 3001 7cf5 45fe d52b E..T.+..0.|.E..+ 0x0010: 4815 222a 0800 3530 272a 0000 25ff d744 H."..50'..%..D 0x0020: ae5e 0500 0809 0a0b 0c0d 0e0f 1011 1213 .^.............. 0x0030: 1415 1617 1819 1a1b 1c1d 1e1f 2021 2223 .............!"# 0x0040: 2425 2627 2829 2a2b 2c2d 2e2f 3031 3233 $%&'()+,-./0123 0x0050: 3435 3637 4567 23:11:10.370344 IP (tos 0x20, ttl 64, id 35612, offset 0, flags [none], length: 84) 72.21.34.42 > 69.254.213.43: icmp 64: echo reply seq 0 0x0000: 4520 0054 8b1c 0000 4001 6a04 4815 222a E..T....@.j.H." 0x0010: 45fe d52b 0000 3d30 272a 0000 25ff d744 E..+..=0'..%..D 0x0020: ae5e 0500 0809 0a0b 0c0d 0e0f 1011 1213 .^.............. 0x0030: 1415 1617 1819 1a1b 1c1d 1e1f 2021 2223 .............!"# 0x0040: 2425 2627 2829 2a2b 2c2d 2e2f 3031 3233 $%&'()+,-./0123 0x0050: 3435 3637 4567 2 packets captured 2 packets received by filter 0 packets dropped by kernel hermes root #

Examples

Expressions allow you to trim out various types of traffic and find exactly what you’re looking for. Mastering the expressions and learning to combine them creatively is what makes one truly powerful withtcpdump. There are three main types of expression: type, dir, andproto.

Type options are host, net, and port. Direction is indicated by dir, and there you can have src, dst, src or dst, and src and dst. Here are a few that you should definitely be comfortable with:

• host // look for traffic based on IP address (also works with hostname if you’re not using -n)
  • # tcpdump host 1.2.3.4
• src, dst // find traffic from only a source or destination (eliminates one side of a host conversation)
  • # tcpdump src 2.3.4.5
  • # tcpdump dst 3.4.5.6
• net // capture an entire network using CIDR notation
  • # tcpdump net 1.2.3.0/24
• proto // works for tcp, udp, and icmp. Note that you don’t have to type proto
  • # tcpdump icmp
• port // see only traffic to or from a certain port
  • # tcpdump port 3389
• src, dst port // filter based on the source or destination port
  • # tcpdump src port 1025 # tcpdump dst port 389
• src/dst, port, protocol // combine all three
  • # tcpdump src port 1025 and tcp
  • # tcpdump udp and src port 53

You also have the option to filter by a range of ports instead of declaring them individually, and to only see packets that are above or below a certain size.

• Port Ranges // see traffic to any port in a range
• tcpdump portrange 21-23
• Packet Size Filter // only see packets below or above a certain size (in bytes)
• tcpdump less 32
• tcpdump greater 128
• [ You can use the symbols for less than, greater than, and less than or equal / greater than or equal signs as well. ]
• // filtering for size using symbols
• tcpdump > 32
• tcpdump <= 128

Writing to a File

tcpdump allows you to send what you’re capturing to a file for later use using the -w option, and then to read it back using the -r option. This is an excellent way to capture raw traffic and then run it through various tools later.

The traffic captured in this way is stored in tcpdump format, which is pretty much universal in the network analysis space. This means it can be read in by all sorts of tools, including Wireshark, Snort, etc.

Capture all Port 80 Traffic to a File

# tcpdump -s 1514 port 80 -w capture_file

Then, at some point in the future, you can then read the traffic back in like so:

Read Captured Traffic back into tcpdump

# tcpdump -r capture_file

Getting Creative

Expressions are nice, but the real magic of tcpdump comes from the ability to combine them in creative ways in order to isolate exactly what you’re looking for. There are three ways to do combinations, and if you’ve studied computers at all they’ll be pretty familar to you:

1. AND
2. and or &&
3. OR
4. or or ||
5. EXCEPT
6. not or !

More Examples

tcpdump -nnvvS src 10.5.2.3 and dst port 3389

tcpdump -nvX src net 192.168.0.0/16 and dst net 10.0.0.0/8 or172.16.0.0/16

tcpdump -nvvXSs 1514 dst 192.168.0.2 and src net and not icmp

tcpdump -vv src mars and not dst port 22

As you can see, you can build queries to find just about anything you need. The key is to first figure out precisely what you’re looking for and then to build the syntax to isolate that specific type of traffic.

Grouping

Also keep in mind that when you’re building complex queries you might have to group your options using single quotes. Single quotes are used in order to tell tcpdump to ignore certain special characters — in this case the “( )” brackets. This same technique can be used to group using other expressions such as host, port, net, etc. Take a look at the command below:

tcpdump src 10.0.2.4 and (dst port 3389 or 22)

If you tried to run this otherwise very useful command, you’d get an error because of the parenthesis. You can either fix this by escaping the parenthesis (putting a \ before each one), or by putting the entire command within single quotes:

tcpdump ‘src 10.0.2.4 and (dst port 3389 or 22)’

Advanced

You can also filter based on specific portions of a packet, as well as combine multiple conditions into groups. The former is useful when looking for only SYNs or RSTs, for example, and the latter for even more advanced traffic isolation.

[ Hint: An anagram for the TCP flags: Unskilled Attackers Pester Real SecurityFolk ]

Show me all URGENT (URG) packets…

# tcpdump ‘tcp[13] & 32!=0‘

Show me all ACKNOWLEDGE (ACK) packets…

# tcpdump ‘tcp[13] & 16!=0‘

Show me all PUSH (PSH) packets…

# tcpdump ‘tcp[13] & 8!=0‘

Show me all RESET (RST) packets…

# tcpdump ‘tcp[13] & 4!=0‘

Show me all SYNCHRONIZE (SYN) packets…

# tcpdump ‘tcp[13] & 2!=0‘

Show me all FINISH (FIN) packets…

# tcpdump ‘tcp[13] & 1!=0‘

Show me all SYNCHRONIZE/ACKNOWLEDGE (SYNACK)packets…

# tcpdump ‘tcp[13]=18‘

[ Note: Only the PSH, RST, SYN, and FIN flags are displayed in tcpdump‘s flag field output. URGs and ACKs are displayed, but they are shown elsewhere in the output rather than in the flags field ]

Keep in mind the reasons these filters work. The filters above find these various packets because tcp[13] looks at offset 13 in the TCP header, the number represents the location within the byte, and the !=0 means that the flag in question is set to 1, i.e. it’s on.

As with most powerful tools, however, there are multiple ways to do things. The example below shows another way to capture packets with specific TCP flags set.

Capture TCP Flags Using the tcpflags Option…

# tcpdump ‘tcp[tcpflags] & & tcp-syn != 0‘

Specialized Traffic

Finally, there are a few quick recipes you’ll want to remember for catching specific and specialized traffic, such as IPv6 and malformed/likely-malicious packets.

IPv6 traffic

# tcpdump ip6

Packets with both the RST and SYN flags set (why?)

# tcpdump ‘tcp[13] = 6’

Traffic with the ‘Evil Bit’ Set

# tcpdump ‘ip[6] & 128 != 0‘

Conclusion

Well, this primer should get you going strong, but the man page should always be handy for the most advanced and one-off usage scenarios. I truly hope this has been useful to you, and feel free to contact me if you have any questions.

Tcpdump usage examples

October 1, 2014

In most cases you will need root permission to be able to capture packets on an interface. Using tcpdump (with root) to capture the packets and saving them to a file to analyze with Wireshark (using a regular account) is recommended over using Wireshark with a root account to capture packets on an "untrusted" interface. See the Wireshark security advisories for reasons why.

See the list of interfaces on which tcpdump can listen:

tcpdump -D

Listen on interface eth0:

tcpdump -i eth0

Listen on any available interface (cannot be done in promiscuous mode. Requires Linux kernel 2.2 or greater):

tcpdump -i any

Be verbose while capturing packets:

tcpdump -v

Be more verbose while capturing packets:

tcpdump -vv

Be very verbose while capturing packets:

tcpdump -vvv

Be verbose and print the data of each packet in both hex and ASCII, excluding the link level header:

tcpdump -v -X

Be verbose and print the data of each packet in both hex and ASCII, also including the link level header:

tcpdump -v -XX

Be less verbose (than the default) while capturing packets:

tcpdump -q

Limit the capture to 100 packets:

tcpdump -c 100

Record the packet capture to a file called capture.cap:

tcpdump -w capture.cap

Record the packet capture to a file called capture.cap but display on-screen how many packets have been captured in real-time:

tcpdump -v -w capture.cap

Display the packets of a file called capture.cap:

tcpdump -r capture.cap

Display the packets using maximum detail of a file called capture.cap:

tcpdump -vvv -r capture.cap

Display IP addresses and port numbers instead of domain and service names when capturing packets (note: on some systems you need to specify -nn to display port numbers):

tcpdump -n

Capture any packets where the destination host is 192.168.1.1. Display IP addresses and port numbers:

tcpdump -n dst host 192.168.1.1

Capture any packets where the source host is 192.168.1.1. Display IP addresses and port numbers:

tcpdump -n src host 192.168.1.1

Capture any packets where the source or destination host is 192.168.1.1. Display IP addresses and port numbers:

tcpdump -n host 192.168.1.1

Capture any packets where the destination network is 192.168.1.0/24. Display IP addresses and port numbers:

tcpdump -n dst net 192.168.1.0/24

Capture any packets where the source network is 192.168.1.0/24. Display IP addresses and port numbers:

tcpdump -n src net 192.168.1.0/24

Capture any packets where the source or destination network is 192.168.1.0/24. Display IP addresses and port numbers:

tcpdump -n net 192.168.1.0/24

Capture any packets where the destination port is 23. Display IP addresses and port numbers:

tcpdump -n dst port 23

Capture any packets where the destination port is is between 1 and 1023 inclusive. Display IP addresses and port numbers:

tcpdump -n dst portrange 1-1023

Capture only TCP packets where the destination port is is between 1 and 1023 inclusive. Display IP addresses and port numbers:

tcpdump -n tcp dst portrange 1-1023

Capture only UDP packets where the destination port is is between 1 and 1023 inclusive. Display IP addresses and port numbers:

tcpdump -n udp dst portrange 1-1023

Capture any packets with destination IP 192.168.1.1 and destination port 23. Display IP addresses and port numbers:

tcpdump -n "dst host 192.168.1.1 and dst port 23"

Capture any packets with destination IP 192.168.1.1 and destination port 80 or 443. Display IP addresses and port numbers:

tcpdump -n "dst host 192.168.1.1 and (dst port 80 or dst port 443)"

Capture any ICMP packets:

tcpdump -v icmp

Capture any ARP packets:

tcpdump -v arp

Capture either ICMP or ARP packets:

tcpdump -v "icmp or arp"

Capture any packets that are broadcast or multicast:

tcpdump -n "broadcast or multicast"

Capture 500 bytes of data for each packet rather than the default of 68 bytes:

tcpdump -s 500

Capture all bytes of data within the packet:

tcpdump -s 0

Article first published March 13, 2010. Last updated October 1, 2014.

tcpdump Cheat Sheet