Prezentacja dotyczy narzędzia tshark - terminalowej wersji Wireshark do automatyzacji analizy ruchu sieciowego. Omówiono instalację, podstawową składnię, przechwytywanie z filtrami BPF oraz zaawansowane formaty wyjściowe, takie jak JSON, CSV, XML i PDML. Przedstawiono także statystyki wbudowane (-z) oraz praktyczne przykłady automatyzacji analizy za pomocą skryptów.
tshark to narzędzie wiersza poleceń do przechwytywania i analizy pakietów sieciowych. Jest częścią pakietu Wireshark.
tshark wchodzi w skład pakietu Wireshark:
tshark --versionSprawdzenie działania:
tshark --version
TShark (Wireshark) 4.2.5 (v4.2.5-0-g5a8b4c9d4e36)
# Debian/Ubuntu sudo apt install tshark # Fedora/RHEL sudo dnf install wireshark-cli # Arch Linux sudo pacman -S wireshark-cli
Po instalacji sprawdź, czy tshark jest dostępny:
tshark -D # lista interfejsów
Może być wymagane dodanie użytkownika do grupy wireshark:
sudo usermod -a -G wireshark $USER
tshark [opcje] [filtr]
Najważniejsze opcje:
Lista dostępnych interfejsów:
tshark -D
1. \Device\NPF_{...} (Ethernet0)
2. \Device\NPF_{...} (Wi-Fi)
3. \Device\NPF_{...} (Loopback)
Przechwytywanie z konkretnego interfejsu:
tshark -i 2 tshark -i "Wi-Fi" tshark -i eth0
Jeśli nie podasz -i, tshark użyje pierwszego interfejsu (lub wyświetli błąd, gdy nie ma interfejsu).
Odczyt zapisanego wcześniej pliku pcap/pcapng:
tshark -r plik.pcap
tshark wyświetli listę pakietów (liczba, czas, źródło, cel, protokół, info).
Przykład wyniku:
1 0.000000 192.168.1.100 → 192.168.1.1 DNS 80 Standard query 0x1234 A example.com
2 0.015234 192.168.1.1 → 192.168.1.100 DNS 120 Standard query response 0x1234 A 93.184.216.34
3 0.120456 192.168.1.100 → 93.184.216.34 TCP 74 49152 → 80 [SYN] Seq=0 Win=65535
Opcja -c zatrzymuje przechwytywanie po N pakietach:
# Przechwyć 100 pakietów z interfejsu eth0 tshark -i eth0 -c 100 # Odczytaj pierwsze 50 pakietów z pliku tshark -r plik.pcap -c 50
Przydatne do:
# Przechwyć i zapisz do pliku pcapng tshark -i eth0 -c 1000 -w wyjscie.pcapng # Zastosuj capture filter przed zapisem tshark -i eth0 -f "port 80" -w http.pcapng
Domyślny format: pcapng (nowy, zalecany).
Jeśli chcesz pcap (starszy):
tshark -i eth0 -w wyjscie.pcap -F pcap
Opcja -F wybiera format pliku.
Opcja -Y stosuje display filter Wireshark podczas odczytu pliku:
# Tylko pakiety HTTP tshark -r plik.pcap -Y http # Tylko żądania GET tshark -r plik.pcap -Y "http.request.method == GET" # Tylko pakiety z błędami TCP tshark -r plik.pcap -Y "tcp.analysis.retransmission"
Filtry wyświetlania są takie same jak w interfejsie graficznym Wireshark – pełna składnia.
Opcja -f stosuje filtr Berkeley Packet Filter (BPF) podczas przechwytywania:
# Tylko ruch HTTP (port 80) tshark -i eth0 -f "port 80" # Tylko ruch z/do konkretnego hosta tshark -i eth0 -f "host 192.168.1.1" # Tylko pakiety TCP tshark -i eth0 -f "tcp" # Tylko ruch DNS (port 53) tshark -i eth0 -f "port 53"
Capture filter odrzuca pakiety w jądrze – wydajniejszy niż display filter.
Opcja -T określa format wyjściowy (domyślnie tekst):
| Format | Opis |
|---|---|
| fields | Wybrane pola (wymaga -e) |
| json | JSON – cały pakiet |
| jsonraw | JSON z surowymi bajtami |
| pdml | Packet Details Markup Language (XML) |
| psml | Packet Summary Markup Language (XML) |
| ek | Elasticsearch JSON (bulk API) |
| tabs | Wynik z separatorami tabulacji |
W połączeniu z -T fields:
# Adresy IP źródła i celu tshark -r plik.pcap -T fields -e ip.src -e ip.dst # Numer pakietu + adresy IP + porty tshark -r plik.pcap -T fields -e frame.number -e ip.src -e tcp.srcport -e ip.dst -e tcp.dstport
Każde -e dodaje jedno pole do wyniku.
Lista dostępnych pól:
tshark -G fields | grep -i "nazwa_pola"
Opcja -E kontroluje formatowanie eksportu:
# Nagłówek + separator przecinek tshark -r plik.pcap -T fields -e ip.src -e ip.dst -E header=y -E separator=, # Cytowanie wartości (dla CSV) tshark -r plik.pcap -T fields -e ip.src -e ip.dst -E header=y -E separator=, -E quote=d # Bez nagłówka, separator tabulacji tshark -r plik.pcap -T fields -e frame.number -e ip.src -E header=n -E separator=\t
Najważniejsze opcje -E:
tshark zawiera wbudowane moduły statystyk (jak w Wireshark):
# Statystyki IO – pakiety na sekundę tshark -r plik.pcap -z io,stat,1 # Rozmowy TCP tshark -r plik.pcap -z conv,tcp # Punkty końcowe IP tshark -r plik.pcap -z endpoints,ip # Hierarchia protokołów tshark -r plik.pcap -z io,phs
W połączeniu z -q (quiet) – wyświetla tylko statystyki, bez listy pakietów.
# Wyodrębnij pary IP źródło → cel (CSV) tshark -r plik.pcap -T fields -e ip.src -e ip.dst -E separator=, -E header=y # Przykładowy wynik: ip.src,ip.dst 192.168.1.100,192.168.1.1 192.168.1.1,192.168.1.100 192.168.1.100,93.184.216.34
Można przekierować do pliku CSV:
tshark -r plik.pcap -T fields -e ip.src -e ip.dst -E separator=, > ip_list.csv
# Eksport całego pliku do JSON tshark -r plik.pcap -T json > plik.json # Tylko wybrane pakiety (z display filtrem) tshark -r plik.pcap -Y http -T json > http.json # JSON raw – surowe bajty w hex tshark -r plik.pcap -T jsonraw > plik_raw.json
Struktura JSON zawiera wszystkie pola każdego pakietu – idealne do dalszej obróbki w Python, Node.js.
Najczęściej używany format do dalszej analizy:
# CSV z wybranymi polami + nagłówek tshark -r plik.pcap -T fields -e frame.number -e ip.src -e ip.dst -e tcp.srcport -e tcp.dstport -E header=y -E separator=, -E quote=d > raport.csv
Gotowy plik CSV można otworzyć w:
tshark obsługuje dwa formaty XML:
# PDML – szczegóły pakietów tshark -r plik.pcap -T pdml > szczegoly.xml # PSML – lista pakietów tshark -r plik.pcap -T psml > lista.xml
PDML zawiera pełną hierarchię protokołów – przydatne do transformacji XSLT.
# Host, URI, kod odpowiedzi, metoda tshark -r plik.pcap -Y http -T fields -e http.host -e http.request.uri -e http.response.code -e http.request.method -E header=y -E separator=|
Przykład wyniku:
http.host|http.request.uri|http.response.code|http.request.method example.com|/index.html|200|GET example.com|/style.css|200|GET example.com|/login|401|POST
Pozwala szybko uzyskać listę wszystkich żądań HTTP z pliku.
# Zapytania DNS i odpowiedzi tshark -r plik.pcap -Y dns -T fields -e dns.qry.name -e dns.a -e dns.flags.response -E header=y -E separator=,
Przykład wyniku:
dns.qry.name,dns.a,dns.flags.response example.com,,0 example.com,93.184.216.34,1 google.com,,0 google.com,142.250.185.78,1
dns.qry.name – zapytana nazwa
dns.a – odpowiedź IPv4 (jeśli istnieje)
dns.flags.response – 0 = zapytanie, 1 = odpowiedź
# Porty, flagi, numery sekwencyjne, okno tshark -r plik.pcap -Y tcp -T fields -e tcp.srcport -e tcp.dstport -e tcp.flags.syn -e tcp.flags.ack -e tcp.flags.reset -e tcp.window_size_value
Najważniejsze pola TCP:
Opcja -O wyświetla szczegóły wybranych protokołów (jak Packet Details w Wireshark):
# Szczegóły HTTP dla każdego pakietu tshark -r plik.pcap -Y http -O http # Kilka protokołów jednocześnie tshark -r plik.pcap -O "http,dns,tcp"
Wynik zawiera drzewiastą strukturę pola protokołu – jak w panelu Packet Details Wireshark.
Przydatne do szczegółowej analizy bez użycia -V (które pokazuje wszystko).
# Wyświetl pełną strukturę każdego pakietu tshark -r plik.pcap -V # Tylko pierwszy pakiet z pełnymi szczegółami tshark -r plik.pcap -c 1 -V
Opcja -V odpowiada kliknięciu pakietu w Wireshark i rozwinięciu wszystkich gałęzi Packet Details.
Pokazuje:
# Wyświetl hex + ASCII każdego pakietu tshark -r plik.pcap -x # Tylko jeden pakiet + hex tshark -r plik.pcap -c 1 -x
Wynik wygląda jak w panelu Packet Bytes Wireshark:
0000 00 11 22 33 44 55 66 77 88 99 aa bb 08 00 45 00 0010 00 34 00 00 40 00 40 06 00 00 c0 a8 01 64 c0 a8 0020 01 01 00 50 00 00 00 00 00 00 00 00 00 00 50 02 0030 20 00 00 00 00 00 00 00
Przydatne do: analizy surowych danych, wykrycia ukrytych wzorców, badania błędów ramek.
-P – wyświetlanie pakietów również podczas zapisu do pliku (print):
# Wyświetlanie pakietów podczas zapisu do pliku tshark -i eth0 -w wyjscie.pcapng -P
-q – quiet (cicho) – nie wyświetla listy pakietów, tylko statystyki / podsumowanie:
# Tylko statystyki IO, bez pakietów tshark -r plik.pcap -q -z io,stat,1 # Tylko podsumowanie na koniec tshark -r plik.pcap -q -z io,phs
-q + -z = idealne połączenie do generowania raportów.
# Lista wszystkich protokołów tshark -G protocols # Policz obsługiwane protokoły tshark -G protocols | wc -l
tshark obsługuje 2000+ protokołów (tyle samo co Wireshark).
Lista zawiera:
Przykład fragmentu:
Protocols: ... HTTP HTTPS ICMP ICMPv6 TCP TELNET TFTP UDP ...
# Lista pól (bardzo długa!) tshark -G fields # Szukaj pól związanych z HTTP tshark -G fields | grep -i "http" # Szukaj konkretnego pola tshark -G fields | grep "ip.src"
Format wyjścia: nazwa_pola\ttyp\topis
Przykład:
ip.src FT_IPv4 Source address ip.dst FT_IPv4 Destination address tcp.port FT_UINT16 TCP Port
Przydatne, gdy szukasz dokładnej nazwy pola do opcji -e.
# Adresy MAC i EtherType tshark -r plik.pcap -T fields -e eth.src -e eth.dst -e eth.type # Ramki broadcast/multicast tshark -r plik.pcap -Y "eth.dst == ff:ff:ff:ff:ff:ff" -T fields -e eth.src -e frame.len
Przykład wyniku:
00:11:22:33:44:55 66:77:88:99:aa:bb 0x0800 ff:ff:ff:ff:ff:ff 00:11:22:33:44:55 0x0806
eth.type – 0x0800 (IPv4), 0x0806 (ARP), 0x86DD (IPv6).
# HTTP – pełne informacje o żądaniu tshark -r plik.pcap -Y http -T fields -e http.host -e http.request.uri -e http.response.code -e http.content_type -E separator=, # DNS – nazwy zapytań i odpowiedzi tshark -r plik.pcap -Y dns -T fields -e dns.qry.name -e dns.resp.name -e dns.a -E separator=, # DHCP – adres IP przydzielony, maska, brama tshark -r plik.pcap -Y dhcp -T fields -e dhcp.option.dhcp -e ip.src -e bootp.option.subnet_mask -e bootp.option.router -E separator=,
Dzięki tym polom można szybko wyodrębnić wszystkie interesujące informacje.
#!/bin/bash # Automatyczna analiza pliku pcap PCAP_FILE=$1 OUTPUT_DIR="raport_$(date +%Y%m%d_%H%M%S)" mkdir -p $OUTPUT_DIR echo "Analizuję plik: $PCAP_FILE" # Lista adresów IP tshark -r "$PCAP_FILE" -T fields -e ip.src -e ip.dst -E separator=, -E header=y > "$OUTPUT_DIR/ip_list.csv" # Statystyki protokołów tshark -r "$PCAP_FILE" -q -z io,phs > "$OUTPUT_DIR/protocols.txt" # Rozmowy TCP tshark -r "$PCAP_FILE" -z conv,tcp > "$OUTPUT_DIR/tcp_conversations.txt" echo "Raport zapisano w: $OUTPUT_DIR"
#!/bin/bash # Analiza wszystkich plików pcap w katalogu for pcap in *.pcap; do echo "=== $pcap ===" tshark -r "$pcap" -q -z io,phs | head -20 tshark -r "$pcap" -T fields -e ip.src -e ip.dst | sort | uniq -c | sort -rn | head -10 echo "" done
PowerShell odpowiednik:
Get-ChildItem *.pcap | ForEach-Object { Write-Host "=== $($_.Name) ===" tshark -r $_.FullName -q -z io,phs }
# Najczęściej odwiedzane hosty HTTP tshark -r plik.pcap -Y http -T fields -e http.host | sort | uniq -c | sort -rn | head -10 # Najaktywniejsze adresy IP tshark -r plik.pcap -T fields -e ip.src | sort | uniq -c | sort -rn | head -10 # Średnia długość pakietu (awk) tshark -r plik.pcap -T fields -e frame.len | awk '{sum+=$1; n++} END {print "Średnia:", sum/n}' # Pakiety z treścią zawierającą "password" (grep) tshark -r plik.pcap -x | grep -i "password"
#!/usr/bin/env python3 import subprocess import csv import io def analizuj_pcap(plik): cmd = [ "tshark", "-r", plik, "-T", "fields", "-e", "frame.number", "-e", "ip.src", "-e", "ip.dst", "-e", "frame.len", "-E", "header=y", "-E", "separator=,", "-E", "quote=d" ] wynik = subprocess.run(cmd, capture_output=True, text=True) reader = csv.DictReader(io.StringIO(wynik.stdout)) for row in reader: print(f"Pakiet {row['frame.number']}: {row['ip.src']} -> {row['ip.dst']} ({row['frame.len']} B)") if __name__ == "__main__": analizuj_pcap("plik.pcap")
Cel: znaleźć liczbę unikalnych adresów IP źródłowych w pliku.
# Rozwiązanie jednowierszowe (bash) tshark -r plik.pcap -T fields -e ip.src | sort -u | wc -l # Z listą IP i liczbą pakietów tshark -r plik.pcap -T fields -e ip.src | sort | uniq -c | sort -rn # Rozwiązanie w Python tshark -r plik.pcap -T fields -e ip.src -E header=n | python -c "import sys; ips = set(line.strip() for line in sys.stdin if line.strip()); print(f'Unikalnych IP: {len(ips)}')"
Wynik: lista IP posortowana malejąco według liczby pakietów.
Cel: wyświetlić host + URI + czas odpowiedzi.
# Host + URI + kod odpowiedzi + czas (frame.time_delta) tshark -r plik.pcap -Y "http.request" -T fields -e http.host -e http.request.uri -e http.request.method -e frame.time_delta -E header=y -E separator=|
Przykład wyniku:
http.host|http.request.uri|http.request.method|frame.time_delta example.com|/index.html|GET|0.000000 example.com|/style.css|GET|0.015234 example.com|/api/data|POST|1.234567
Można dodać -e http.response_in aby zobaczyć, w którym pakiecie jest odpowiedź.
Cel: znaleźć żądania HTTP, które miały najdłuższy czas odpowiedzi.
# Czas odpowiedzi (delta między żądaniem a odpowiedzią) tshark -r plik.pcap -Y "http.response" -T fields -e http.response.code -e http.request.uri -e http.time -E header=y -E separator=, | sort -t, -k3 -rn | head -10
Pole http.time to czas między żądaniem a odpowiedzią (w sekundach).
Wynik:
http.response.code,http.request.uri,http.time 200,/heavy-report.php,12.345 404,/not-found,5.678 200,/index.html,0.123
Cel: znaleźć pakiety z retransmisjami TCP.
# Liczba retransmisji tshark -r plik.pcap -Y "tcp.analysis.retransmission" -T fields -e frame.number -e ip.src -e tcp.srcport -e ip.dst -e tcp.dstport -e tcp.analysis.ack_rtt # Procent retransmisji total=$(tshark -r plik.pcap -Y tcp -T fields -e frame.number | wc -l) retrans=$(tshark -r plik.pcap -Y "tcp.analysis.retransmission" -T fields -e frame.number | wc -l) echo "Retransmisje: $retrans / $total = $(echo "scale=2; $retrans*100/$total" | bc)%"
Pole tcp.analysis.ack_rtt – RTT (Round Trip Time) oszacowane przez Wireshark.
#!/bin/bash # generuj_raport.sh – kompleksowy raport z pliku pcap PCAP=$1 echo "==========================================" echo " RAPORT Z ANALIZY: $PCAP" echo "==========================================" echo "" echo "1. Podstawowe informacje:" capinfos "$PCAP" | grep -E "(Number of packets|File size|Capture duration|Data rate)" echo "" echo "2. Hierarchia protokołów:" tshark -r "$PCAP" -q -z io,phs echo "" echo "3. Top 10 adresów IP źródłowych:" tshark -r "$PCAP" -T fields -e ip.src | sort | uniq -c | sort -rn | head -10 echo "" echo "4. Retransmisje TCP:" tshark -r "$PCAP" -Y "tcp.analysis.retransmission" -T fields -e frame.number -e ip.src -e ip.dst | head -20
# Pakiety na sekundę (interwał 1 s) tshark -r plik.pcap -z io,stat,1 # Bajty na sekundę z podziałem na protokoły tshark -r plik.pcap -z io,stat,1,http,dns,tcp # Z display filtrem – tylko HTTP tshark -r plik.pcap -z io,stat,1,http
Wynik to tabela z kolumnami: czas, liczba pakietów, bajty/s.
Przydatne do wykrycia skoków ruchu lub okresowości.
# Lista wszystkich rozmów TCP tshark -r plik.pcap -z conv,tcp # Z ograniczeniem do 10 największych tshark -r plik.pcap -z conv,tcp | head -20
Wynik zawiera:
To samo co Statistics → Conversations w Wireshark.
# Lista wszystkich adresów IP z liczbą pakietów tshark -r plik.pcap -z endpoints,ip # To samo co Statistics → Endpoints w Wireshark tshark -r plik.pcap -z endpoints,ip -q
Dostępne typy endpoints:
# Drzewo statystyk HTTP tshark -r plik.pcap -z http,tree
Wynik pokazuje:
Przykład:
===================================================================
HTTP Statistics (tree)
===================================================================
example.com
/index.html
GET
200 (5 pakietów, 12 kB)
/style.css
GET
200 (2 pakiety, 4 kB)
google.com
/search?q=test
GET
200 (3 pakiety, 8 kB)
# Drzewo statystyk DNS tshark -r plik.pcap -z dns,tree
Wynik pokazuje:
Przykład:
=================================================================== DNS Statistics (tree) =================================================================== example.com A (3 zapytania, 3 odpowiedzi, avg RTT: 15 ms) google.com A (5 zapytań, 5 odpowiedzi, avg RTT: 8 ms) AAAA (2 zapytania, 2 odpowiedzi, avg RTT: 10 ms)
# Statystyki DHCP tshark -r plik.pcap -z bootp,stat
Wynik zawiera:
Przydatne do diagnostyki problemów z adresacją DHCP.
# Expert Info – podsumowanie problemów tshark -r plik.pcap -z expert
Wynik grupuje problemy według kategorii:
To samo co Analyze → Expert Info w Wireshark.
# Monitorowanie ruchu HTTP na żywo tshark -i eth0 -f "port 80" -T fields -e http.host -e http.request.uri -E separator=, # Monitorowanie połączeń TCP (nowe sesje) tshark -i eth0 -f "tcp" -Y "tcp.flags.syn == 1 and tcp.flags.ack == 0" -T fields -e ip.src -e tcp.srcport -e ip.dst -e tcp.dstport # Zapis do pliku + statystyki na żywo tshark -i eth0 -w live.pcapng -q -z io,stat,5
tshark działa jak tcpdump, ale z możliwością zaawansowanego formatowania wyjścia.
Automatyzacja przechwytywania na Linux (cron):
# /etc/cron.d/capture # Przechwytywanie 10 minut co godzinę 0 * * * * root timeout 600 tshark -i eth0 -w /var/log/capture/$(date +\%Y\%m\%d_\%H\%M\%S).pcapng
Na Windows (Task Scheduler):
# PowerShell skrypt uruchamiany przez Task Scheduler $timestamp = Get-Date -Format "yyyyMMdd_HHmmss" $filename = "C:\captures\log_$timestamp.pcapng" Start-Process -FilePath "tshark" -ArgumentList "-i 2 -a duration:600 -w $filename" -NoNewWindow -Wait
| Cecha | tcpdump | tshark |
|---|---|---|
| Rozmiar | Bardzo mały (~1 MB) | Większy (~50 MB) |
| Formaty wyjściowe | Tylko tekst | JSON, CSV, XML, PDML, PSML, fields |
| Wyodrębnianie pól | Ograniczone | Pełne (2000+ protokołów) |
| Display filtry | Nie | Tak (składnia Wireshark) |
| Statystyki -z | Nie | Tak (IO, conv, endpoints, expert) |
| Wydajność | Bardzo wysoka | Niższa (większe obciążenie CPU) |
| Dostępność | Każdy Linux | Wymaga instalacji Wireshark |
Cel: kompleksowa analiza pliku pcap jednym poleceniem.
#!/bin/bash # analyze_pcap.sh – pełna analiza pliku pcap PCAP=$1 echo "=== 1. INFORMACJE OGÓLNE ===" capinfos "$PCAP" echo "=== 2. RETRANSMISJE TCP ===" tshark -r "$PCAP" -q -z expert echo "=== 3. TOP 10 ROZMÓW ===" tshark -r "$PCAP" -z conv,tcp | head -15 echo "=== 4. ŻĄDANIA HTTP ===" tshark -r "$PCAP" -Y "http.request" -T fields -e http.host -e http.request.uri -e http.request.method -E separator=, echo "=== 5. NAJWOLNIEJSZE ODPOWIEDZI ===" tshark -r "$PCAP" -Y "http.response" -T fields -e http.response.code -e http.request.uri -e http.time | sort -t$'\t' -k3 -rn | head -5
tshark jest wolniejszy od tcpdump – ładuje cały plik do pamięci?
W rzeczywistości tshark przetwarza plik strumieniowo, ale analiza protokołów (zwłaszcza JSON/PDML) jest kosztowna.
Wskazówki wydajnościowe:
tshark -G fields | grep nazwa
Odpowiedź: -Y to display filter (składnia Wireshark, stosowany przy odczycie pliku). -f to capture filter (BPF, stosowany przy przechwytywaniu na żywo).
Odpowiedź: -T fields z -E separator=, -E header=y -E quote=d – daje poprawne CSV.
Odpowiedź: Użyj opcji -q (quiet) w połączeniu z -z (statystyki).
Odpowiedź: tshark -G fields | grep "ip.src" – pole nazywa się ip.src.
Odpowiedź: Gdy potrzebujemy zaawansowanego formatowania (JSON, CSV, fields), statystyk wbudowanych (-z) lub wyodrębniania pól protokołów (-e).
Dziękujemy za uwagę. W następnej części poznamy zaawansowane display filtry Wireshark – wyrażenia regularne, porównania, funkcje, zapisywanie i zarządzanie filtrami, zaawansowane przykłady analizy.
Praca własna:
tshark -z conv,tcp na pliku pcap i zinterpretuj wynik