Prezentacja opisuje formaty plików pcap i pcapng służące do przechowywania przechwyconych pakietów sieciowych. Omówiono strukturę obu formatów, w tym bloki pcapng (SHB, IDB, EPB) oraz narzędzia do ich przetwarzania: capinfos, editcap, mergecap i text2pcap. Przedstawiono również wykorzystanie języków Python (scapy, pyshark, dpkt) do automatyzacji analizy plików pcap.
pcap (packet capture) – binarny format pliku do przechowywania przechwyconych pakietów sieciowych.
Plik pcap zawiera:
To najpopularniejszy format wymiany danych między narzędziami analitycznymi – Wireshark, tcpdump, Snort, Suricata i setki innych.
Oba formaty są wciąż używane – pcap dla prostoty i kompatybilności, pcapng dla zaawansowanych zastosowań.
Plik pcap składa się z dwóch części:
# Struktura pliku pcap
+-----------------------+
| Global Header (24B) |
+-----------------------+
| Packet Record 1 |
| - Timestamp (16B) |
| - Captured len (4B) |
| - Original len (4B) |
| - Packet data |
+-----------------------+
| Packet Record 2 |
| ... |
+-----------------------+
Global Header – 24 bajty na początku pliku:
# Struktura Global Header
Bajty 0-3: Magic number (0xa1b2c3d4 lub 0xd4c3b2a1)
Bajty 4-5: Version major (2)
Bajty 6-7: Version minor (4)
Bajty 8-11: Timezone offset (0 = UTC)
Bajty 12-15:Timestamp accuracy (0)
Bajty 16-19:Snaplen (maks. długość pakietu)
Bajty 20-23:Link type (DLT)
Magic number – 0xa1b2c3d4 (big-endian) lub 0xd4c3b2a1 (little-endian). Służy do wykrywania kolejności bajtów (endianness) pliku.
Snaplen (snapshot length) – maksymalna liczba bajtów zapisanych z każdego pakietu (domyślnie 262144). Jeśli pakiet jest dłuższy, reszta jest ucinana.
Link type (DLT) – typ łącza danych. Określa, jak interpretować dane pakietu.
Najczęstsze DLT:
Każdy zapisany pakiet ma 16-bajtowy nagłówek rekordu + dane:
# Packet Record Header (16 bajtów)
Bajty 0-3: Timestamp seconds (Unix time)
Bajty 4-7: Timestamp microseconds
Bajty 8-11: Captured length (bajty zapisane w pliku)
Bajty 12-15:Original length (rzeczywista długość pakietu)
Bajty 16+: Packet data (captured length bajtów)
Timestamp – czas przechwycenia w Unix timestamp (sekundy od 1970-01-01). Część mikrosekundowa daje precyzję do mikrosekundy.
Captured length ≤ Original length (gdy snaplen jest mniejszy niż pakiet).
Link type w Global Header określa, jaki nagłówek warstwy 2 zawiera każdy pakiet:
| DLT | Nazwa | Nagłówek | Zastosowanie |
|---|---|---|---|
| 1 | DLT_EN10MB | Ethernet II (14 B) | Sieci przewodowe |
| 105 | DLT_IEEE802_11 | 802.11 (24+ B) | Wi-Fi |
| 113 | DLT_LINUX_SLL | Linux cooked (16 B) | Raw socket (tcpdump) |
| 12 | DLT_RAW | Brak | Surowy IP |
| 101 | LINKTYPE_RAW | Brak (nagłówek IP) | Surowy IP (wartość 101 w pliku pcap) |
| 0 | DLT_NULL | 4 B (address family) | BSD loopback |
Wireshark automatycznie rozpoznaje DLT i stosuje odpowiedni parser.
Te ograniczenia były motywacją do stworzenia pcapng.
pcapng (PCAP Next Generation) – nowy format przechowywania przechwyconych pakietów. Rozszerza możliwości pcap o elastyczną strukturę blokową.
Cechy pcapng:
Każdy blok w pcapng ma wspólny nagłówek:
# Nagłówek bloku pcapng (8 bajtów)
Bajty 0-3: Block Type (4 bajty)
Bajty 4-7: Block Total Length (4 bajty) – długość całego bloku
...
Bajty N-4..N-1: Block Total Length (powtórzony)
Block Type identyfikuje rodzaj bloku:
Section Header Block (SHB) – pierwszy blok w pliku pcapng. Określa wersję formatu i metadane sekcji.
Struktura:
# SHB (minimum 28 bajtów)
Block Type: 0x0A0D0D0A (magic pcapng)
Block Total Length
Byte Order Magic: 0x1A2B3C4D (wykrycie endianness)
Major Version: 1
Minor Version: 0
Section Length: -1 (nieznana) lub długość
Opcje (zmienna): komentarz, nazwa aplikacji, SHA256
Block Total Length (powtórzony)
Plik może zawierać wiele sekcji – każda zaczyna się od SHB.
Interface Description Block (IDB) – opisuje interfejs, z którego pochodzą pakiety.
# IDB
Block Type: 0x00000001
Block Total Length
Link Type: DLT (jak w pcap)
Reserved: 0
Snaplen: maks. długość pakietu dla tego interfejsu
Opcje (zmienna):
- if_name: nazwa interfejsu (np. eth0, \Device\NPF_{...})
- if_description: opis
- if_MAC: adres MAC
- if_speed: prędkość (bps)
- if_tsresol: rozdzielczość timestampu (domyślnie 10^-6)
Block Total Length (powtórzony)
Enhanced Packet Block (EPB) – główny blok do przechowywania pakietów w pcapng. Rozszerza Packet Record z pcap o dodatkowe informacje.
# EPB
Block Type: 0x00000006
Block Total Length
Interface ID: który interfejs (indeks IDB)
Timestamp (High + Low): 64-bitowa wartość
Captured Packet Length: długość zapisana
Original Packet Length: oryginalna długość
Packet Data: dane pakietu
Opcje (zmienna):
- komentarz (opt_comment)
- flagi (np. direction: inbound/outbound)
- hash (SHA1, MD5)
- pakiet został przycięty (dropcount)
Block Total Length (powtórzony)
EPB używa 64-bitowego timestampu (High + Low) zamiast 32-bit + mikrosekundy.
Domyślna rozdzielczość: mikrosekundy (10^-6 s). Można zmienić przez opcję if_tsresol w IDB.
Przykład timestampu:
# Timestamp 64-bit – domyślnie mikrosekundy Timestamp High (4 bajty): 0x00000000 Timestamp Low (4 bajty): 0x12345678 # Wartość = High * 2^32 + Low = 0x12345678 us # Czas Unix: 0x12345678 us = 305419896 us ≈ 305.42 s
Dzięki 64 bitom timestamp może reprezentować czas z wysoką precyzją bez przepełnienia (w odróżnieniu od 32-bitowych sekund Unixowych – problem roku 2038).
Simple Packet Block (SPB) – lżejsza wersja EPB. Nie zawiera timestampu i interfejsu – używa domyślnych wartości z sekcji.
# SPB
Block Type: 0x00000003
Block Total Length
Original Packet Length
Packet Data (reszta pakietu)
Block Total Length (powtórzony)
Zalety: mniejszy narzut na pakiet – oszczędność miejsca i czasu zapisu.
Wady: brak timestampu (używany jest czas ostatniego EPB lub domyślny), brak możliwości identyfikacji interfejsu.
Przydatny przy szybkim przechwytywaniu, gdy timestamp nie jest krytyczny.
Name Resolution Block (NRB) – przechowuje pary adres IP ↔ nazwa hosta (DNS) oraz adres MAC ↔ nazwa producenta (OUI).
# NRB
Block Type: 0x00000004
Block Total Length
Records (zmienna):
- 192.168.1.1 → gwiazda.lan (DNS)
- 00:11:22:33:44:55 → Intel Corp (OUI)
- nsls: nazwa serwera DNS
Block Total Length (powtórzony)
NRB umożliwia przenoszenie rozpoznanych nazw razem z plikiem pcapng – analiza bez dostępu do DNS.
Wireshark może dodawać NRB podczas zapisu, jeśli włączono rozpoznawanie nazw.
Interface Statistics Block (ISB) – przechowuje statystyki interfejsu zebrane podczas przechwytywania.
# ISB
Block Type: 0x00000005
Block Total Length
Interface ID: indeks interfejsu
Timestamp (High+Low): czas generowania statystyk
Opcje:
- isb_starttime: czas rozpoczęcia
- isb_endtime: czas zakończenia
- isb_ifrecv: liczba odebranych pakietów
- isb_ifdrop: liczba utraconych pakietów
- isb_filteraccept: pakiety zaakceptowane przez filtr
- isb_osdrop: dropy systemowe
- isb_usrdeliv: pakiety dostarczone do aplikacji
Block Total Length (powtórzony)
Decryption Secrets Block (DSB) – nowość w pcapng (2018+). Przechowuje klucze deszyfrujące (TLS, SSL, WireGuard) dołączone do pliku.
Zawartość DSB:
Format secret type: tls.key_log, tls.rsa, wireguard.decryption_key.
# Przykład DSB z kluczami TLS
Block Type: 0x0000000A
Secrets Type: tls.key_log
Secrets Data: CLIENT_RANDOM xxx yyy
Custom Block (Custom Data Block) – blok o typie z zakresu 0x00000B00–0x00000BFF (prywatne) lub zarejestrowane przez organizację.
Umożliwia:
Przykład użycia: Zeek (Bro) zapisuje w custom block informacje o połączeniu HTTP.
Format:
# Custom Block (prywatny użytek)
Block Type: 0x00000B00
Block Total Length
Custom Data (dowolne dane binarne)
Block Total Length (powtórzony)
| Cecha | pcap | pcapng |
|---|---|---|
| Liczba interfejsów | Jeden | Wiele |
| Timestamp | 32-bit + us (16 B) | 64-bit (zmienna rozdzielczość) |
| Komentarze | Brak | Tak (opt_comment) |
| Statystyki | Brak | ISB (Interface Statistics) |
| Klucze TLS | Brak | DSB (Decryption Secrets) |
| Rozszerzenia | Brak | Custom Block |
| Rozmiar pliku | Mniejszy narzut | Większy (bardziej elastyczny) |
| Kompatybilność | Bardzo wysoka | Wysoka (Wireshark 2+, tcpdump 4.99+) |
| Zalecany | Tylko dla starych narzędzi | Wszystkie nowe projekty |
capinfos – narzędzie z pakietu Wireshark. Wyświetla szczegółowe informacje o plikach pcap/pcapng.
# Podstawowe użycie capinfos plik.pcap # Wynik: File name: plik.pcap File type: Wireshark/tcpdump/... - pcap File encapsulation: Ethernet File timestamp precision: microseconds (6) Packet size limit: file hdr: 262144 bytes Number of packets: 1.5 k File size: 2.3 MB Data size: 2.1 MB Capture duration: 300.42 seconds First packet time: 2024-01-15 10:00:00.123456 Last packet time: 2024-01-15 10:05:00.543210 Data byte rate: 7.0 kBps Data bit rate: 56 kbps Average packet size: 1.4 kB Average packet rate: 5.0 packets/s
capinfos obsługuje kilka formatów wyjścia:
# Wyjście maszynowe (-M) capinfos -M plik.pcap # Wynik: file_name=plik.pcap file_type=Wireshark/tcpdump/... - pcap number_of_packets=1500 capture_duration=300.42 ... # Tabela dla wielu plików (-T) capinfos -T *.pcap
capinfos pozwala wybrać, które informacje wyświetlić:
# Tylko czas trwania capinfos -c -d plik.pcap # Wynik: 300.42 # Tylko liczba pakietów i rozmiar capinfos -c -s plik.pcap # Tylko typ enkapsulacji capinfos -E plik.pcap # Sprawdź typ pliku (pcap/pcapng) capinfos -t plik.pcap
Lista opcji: -c (packets), -d (duration), -s (size), -E (encapsulation), -t (file type), -a (start time), -e (end time), -y (data rate).
Przykład: zbieranie statystyk ze wszystkich plików pcap w katalogu:
for f in *.pcap; do capinfos -c -d -s -y "$f" done
lub z opcją tabeli:
capinfos -T -c -d -s -y *.pcap
Wynik tabeli można przekierować do pliku CSV i otworzyć w Excelu:
capinfos -T -c -d -s -y *.pcap > statystyki.csv
editcap – narzędzie do edycji i przycinania plików pcap/pcapng. Pozwala wybrać zakres pakietów, zmienić timestamp, przyciąć snaplen, usunąć duplikaty.
Składnia podstawowa:
editcap [opcje] plik_wejsciowy plik_wyjsciowy
Przykład – kopiowanie całego pliku:
editcap -F pcapng oryginal.pcap kopia.pcapng
Opcja -F określa format wyjścia (pcap, pcapng, pcap-ng).
Opcja -r (range) wybiera pakiety według numeru (1-indeksowane):
# Pakiety 1-100 editcap -r 1-100 duzy.pcap pierwsze100.pcap # Pakiety 50-200 editcap -r 50-200 duzy.pcap srodek.pcap # Tylko pakiet 1 editcap -r 1 duzy.pcap pierwszy.pcap # Od pakietu 100 do końca editcap -r 100-0 duzy.pcap od100.pcap # Lista zakresów (pakiety 1-50 i 100-200) editcap -r 1-50,100-200 duzy.pcap wybrane.pcap
Opcja -c dzieli plik na mniejsze pliki po N pakietów każdy:
# Podziel co 1000 pakietów editcap -c 1000 duzy.pcap czesc # Powstanie: czesc_00001.pcap, czesc_00002.pcap, ... # Podziel co 500 pakietów editcap -c 500 duzy.pcap part
Przydatne, gdy plik jest za duży do otwarcia w Wireshark (np. > 1 GB).
Można też dzielić według czasu:
# Podziel co 60 sekund editcap -i 60 duzy.pcap rozdzial
Opcja -s (snaplen) zmienia maksymalną długość przechowywanego pakietu:
# Przycięcie do 128 bajtów (tylko nagłówki) editcap -s 128 pelne.pcap przyciete.pcap # Przycięcie do 64 bajtów editcap -s 64 pelne.pcap tylko_naglowki.pcap # Przywrócenie pełnego snaplen (262144) editcap -s 262144 przyciete.pcap pelne.pcap # UWAGA: nie odzyskasz uciętych danych!
Zmniejszenie snaplen redukuje rozmiar pliku – przydatne do szybszej transmisji.
Opcja -t modyfikuje timestamp wszystkich pakietów:
# Przesuń czas o +3600 sekund (1 godzina do przodu) editcap -t 3600 plik.pcap przesuniety.pcap # Przesuń czas o -1800 sekund (30 minut do tyłu) editcap -t -1800 plik.pcap cofniety.pcap # Ustaw pierwszy pakiet na czas 0 (Unix epoch) editcap -t 0 plik.pcap od_zera.pcap # Uwaga: -t 0 ustawia bezwzględny czas każdego pakietu na 0
Opcja -T (adjustment) – precyzyjna korekta: -T 0.001 (1 ms do przodu).
Przydatne do synchronizacji czasu między plikami z różnych źródeł.
Opcja -d usuwa zduplikowane pakiety (te same dane, ten sam czas):
# Usuń duplikaty editcap -d plik_z_duplikatami.pcap czysty.pcap # Usuń duplikaty z uwzględnieniem różnicy czasu (100 ms) editcap -D 100 plik_z_duplikatami.pcap czysty2.pcap
Opcja -D (z wielką literą) – próg czasowy w mikrosekundach. Dwa pakiety są uznane za duplikaty, jeśli mają te same dane, a różnica czasu ≤ próg.
Przydatne przy czyszczeniu plików z przechwyceń TAP/SPAN, gdzie ten sam pakiet może być przechwycony dwukrotnie.
mergecap -w polaczony.pcap plik1.pcap plik2.pcap
editcap -A "2024-01-15 10:00:00" -B "2024-01-15 11:00:00" plik.pcap wycinek.pcap
mergecap – narzędzie do łączenia plików pcap/pcapng w jeden plik, z domyślnym sortowaniem po czasie.
# Scal dwa pliki mergecap -w scalony.pcap plik1.pcap plik2.pcap # Scal wszystkie pliki z katalogu mergecap -w wszystko.pcap *.pcap
Domyślnie mergecap sortuje pakiety według timestampu (rosnąco).
Opcja -w określa plik wyjściowy.
# Bez sortowania (jak podano pliki) mergecap -a -w bez_sortowania.pcap pierwszy.pcap drugi.pcap
Uwaga: jeśli pomieszasz pliki z różnych interfejsów, mergecap zachowa Interface ID z pcapng.
Scenariusz: przechwytywanie całodobowe z rotacją co godzinę → 24 pliki. Chcesz jeden plik do analizy.
# Scal wszystkie godziny w jeden plik mergecap -a log_00.pcap log_01.pcap ... log_23.pcap -w caly_dzien.pcap # Lub prościej z wildcard (*) mergecap -a log_*.pcap -w caly_dzien.pcap # Sprawdź rozmiar i liczbę pakietów capinfos caly_dzien.pcap
Wynik: jeden plik pcapng z 24 milionami pakietów (przy średnio 1 Mpps).
reordercap – narzędzie do sortowania pakietów w pliku pcap/pcapng według timestampu.
Przydatne gdy:
# Sortuj pakiety w pliku reordercap niesortowany.pcap posortowany.pcap # Sprawdź różnicę capinfos niesortowany.pcap posortowany.pcap
reordercap nie zmienia treści pakietów – tylko przestawia je w kolejności rosnącego timestampu.
text2pcap – narzędzie do konwersji plików tekstowych (hex dump) na format pcap/pcapng.
Zastosowania:
# Podstawowe użycie text2pcap -l 1 hex_dump.txt wyjscie.pcap # -l 1: DLT_EN10MB (Ethernet) # -l 113: DLT_LINUX_SLL # -l 105: DLT_IEEE802_11
text2pcap akceptuje kilka formatów wejściowych. Najprostszy: hex z offsetami (jak w tcpdump -X).
# Standardowy format hex dump dla text2pcap 000000 00 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF 000016 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F ... # Można też użyć formatu Wireshark (hex dump z ASCII) 0000 00 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF .."3DUfw..... 0016 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F ................
Każdy wiersz: offset (hex) + bajty (hex) lub bajty w linii.
Puste linie oddzielają pakiety.
Opcja -t określa timestamp w formacie YYYY-MM-DD HH:MM:SS.
od -A x -t x1z.
Przykład 1: konwersja dumpu z tcpdump -X:
# Przechwyć z wyjściem hex (tcpdump -X) sudo tcpdump -i eth0 -X -c 5 > dump.txt # Konwertuj na pcap text2pcap -l 1 dump.txt odtworzony.pcap
Przykład 2: generowanie testowego pakietu:
# Plik (ramka Ethernet + IP + UDP) 000000 FF FF FF FF FF FF 00 11 22 33 44 55 08 00 45 00 000016 00 1C 00 01 00 00 40 11 00 00 C0 A8 01 01 C0 A8 000032 01 02 00 35 00 35 00 08 00 00 01 02 03 04 # Konwersja text2pcap -l 1 test.txt test.pcap
rawshark – narzędzie z pakietu Wireshark do analizy przetworzonych danych (bez przechwytywania). Odczyta dane ze stdin i zastosuje parser Wireshark.
# rawshark – podstawowe użycie cat dane.bin | rawshark -r - -d encap:EN10MB # Przykład: hex dump przez rawshark echo "0011223344556677" | rawshark -r - -d encap:EN10MB
rawshark wymaga określenia enkapsulacji (-d encap:...) i jest przydatny do szybkiego testowania parserów.
Nie wymaga pliku pcap – dane są podawane na stdin.
rawshark może odbierać dane bezpośrednio z dumpcap (przechwytywanie i analiza w potoku):
# dumpcap zapisuje do stdout (-P) → rawshark dumpcap -i eth0 -P -w - | rawshark -r - -d encap:EN10MB
Opcje rawshark:
Przykład z filtrowaniem:
dumpcap -i eth0 -P -w - | rawshark -r - -d encap:EN10MB -Y "http.request" -T fields -e http.host
tshark -r odczytuje plik pcap/pcapng i wyświetla wybrane pola.
# Odczytaj pakiety z pliku tshark -r plik.pcap # Wyświetl konkretne pola (-T fields -e) tshark -r plik.pcap -T fields -e frame.number -e ip.src -e ip.dst -e http.host # Z filtrem wyświetlania (-Y) tshark -r plik.pcap -Y "http.request" -T fields -e http.request.uri
Opcja -e (field) wyciąga konkretne pole protokołu. Lista pól: tshark -G fields | grep nazwa.
tcpdump -r odczytuje plik pcap zamiast przechwytywać z interfejsu.
# Podstawowy odczyt tcpdump -r plik.pcap # Z filtrem BPF (odczyt z pliku też może filtrować) tcpdump -r plik.pcap port 80 # Szczegółowe wyświetlanie (-X hex dump, -xx raw hex) tcpdump -r plik.pcap -X # Tylko nagłówki (-q zwięzły format) tcpdump -r plik.pcap -q # Statystyki na koniec (-z) tcpdump -r plik.pcap -z
W przeciwieństwie do tshark, tcpdump -r używa składni BPF (nie display filter Wireshark).
Scapy – potężna biblioteka Pythona do manipulacji pakietami. Odczyta pliki pcap i pcapng.
from scapy.all import rdpcap, IP, TCP # Odczyt pliku packets = rdpcap("plik.pcap") # Iteracja po pakietach for pkt in packets: if pkt.haslayer(IP): print(f"{pkt[IP].src} → {pkt[IP].dst}") # Zapis do nowego pliku wrpcap("wycinek.pcap", packets[:100])
Scapy obsługuje zarówno pcap, jak i pcapng (od wersji 2.4.5+).
from scapy.all import rdpcap, IP, TCP, UDP packets = rdpcap("plik.pcap") # Filtruj tylko HTTP (port 80 TCP) http_pkts = [p for p in packets if p.haslayer(TCP) and (p[TCP].sport == 80 or p[TCP].dport == 80)] print(f"Znaleziono {len(http_pkts)} pakietów HTTP") # Grupowanie po adresie IP źródła ip_counts = {} for p in http_pkts: if p.haslayer(IP): src = p[IP].src ip_counts[src] = ip_counts.get(src, 0) + 1 # Najaktywniejsi nadawcy for ip, count in sorted(ip_counts.items(), key=lambda x: x[1], reverse=True)[:10]: print(f"{ip}: {count}")
pyshark – wrapper Pythona na tshark. Używa silnika parsującego Wireshark, więc obsługuje wszystkie protokoły.
import pyshark # Odczyt pliku cap = pyshark.FileCapture("plik.pcap") # Iteracja for pkt in cap: print(pkt.ip.src, pkt.ip.dst, pkt.highest_layer) # Z filtrem display (składnia Wireshark) cap2 = pyshark.FileCapture("plik.pcap", display_filter="http.request") # Dostęp do pól protokołu for pkt in cap2: if hasattr(pkt, 'http'): print(pkt.http.request_uri, pkt.http.host)
dpkt – lekka biblioteka Pythona do parsowania pakietów i plików pcap bez zależności zewnętrznych.
import dpkt # Odczyt pliku pcap with open("plik.pcap", "rb") as f: pcap = dpkt.pcap.Reader(f) for ts, buf in pcap: # ts – timestamp (Unix time) # buf – surowe bajty pakietu eth = dpkt.ethernet.Ethernet(buf) if isinstance(eth.data, dpkt.ip.IP): ip = eth.data print(f"{ts}: {ip.src} → {ip.dst}") # Odczyt pcapng with open("plik.pcapng", "rb") as f: pcapng = dpkt.pcapng.Reader(f) for ts, buf in pcapng: # podobnie jak pcap
Wireshark oferuje pełną obsługę obu formatów:
Wireshark automatycznie rozpoznaje DLT i stosuje odpowiedni parser.
Przykład: skrypt Bash przetwarzający wszystkie pliki pcap w katalogu:
#!/bin/bash # Skrypt: analiza_zbiorcza.sh for f in *.pcap; do echo "=== $f ===" # Informacje o pliku capinfos -c -d -s -y "$f" # Wyciągnij adresy IP tshark -r "$f" -T fields -e ip.src -e ip.dst | sort | uniq -c | sort -rn | head -10 echo "" done
Wynik: dla każdego pliku – statystyki + top 10 adresów IP.
Można rozszerzyć o generowanie raportu HTML lub CSV.
Scenariusz: masz 5 plików pcap z różnych interfejsów. Chcesz jeden plik, tylko pierwsze 1000 pakietów, przycięty do 128 B.
# Krok 1: Scal pliki z sortowaniem mergecap -a eth0.pcap wlan0.pcap tun0.pcap -w polaczone.pcap # Krok 2: Wybierz pierwsze 1000 pakietów editcap -r 1-1000 polaczone.pcap pierwsze_1000.pcap # Krok 3: Przytnij snaplen do 128 bajtów editcap -s 128 pierwsze_1000.pcap gotowe_do_analizy.pcap # Sprawdź wynik capinfos gotowe_do_analizy.pcap
Efekt: jeden plik pcap ~100 kB zamiast 5 plików ~1 GB.
Generowanie podsumowania dla wielu plików:
# Zbierz statystyki i sformatuj capinfos -T -c -d -s -y *.pcap | awk -F',' 'NR>1 { packets+=$2; duration+=$3; size+=$4; rate+=$5 } END { printf "Razem: %d pakietów, %.2f s, %.2f MB, średnia przepustowość: %.2f kbps\n", packets, duration, size/1e6, rate }'
Wynik:
Razem: 15423 pakietów, 3600.42 s, 25.67 MB, średnia przepustowość: 57.12 kbps
Można łatwo rozszerzyć o inne metryki (liczba pakietów na sekundę, średni rozmiar).
Skrypt Python: odczyt pliku pcap, ekstrakcja czasu i rozmiaru → wykres przepustowości (wymaga matplotlib).
from scapy.all import rdpcap, IP import matplotlib.pyplot as plt from collections import defaultdict import time packets = rdpcap("plik.pcap") # Grupowanie po sekundach traffic = defaultdict(lambda: {"bytes": 0, "pkts": 0}) for pkt in packets: sec = int(pkt.time) traffic[sec]["bytes"] += len(pkt) traffic[sec]["pkts"] += 1 # Wykres przepustowości times = sorted(traffic.keys()) bps = [traffic[t]["bytes"] * 8 / 1e6 for t in times] # Mbps plt.plot(times, bps) plt.xlabel("Czas (Unix timestamp)") plt.ylabel("Przepustowość (Mbps)") plt.title("Ruch sieciowy w czasie") plt.show()
Przy dużej skali (terabajty pcaps), narzędzia jak Wireshark nie wystarczają. Potrzebne są systemy do indeksowania i wyszukiwania.
Arkime przechowuje oryginalne pliki pcap na dysku, a metadane w Elasticsearch. Zapytanie: miliony pakietów w sekundę.
Pliki pcap mogą zawierać dane wrażliwe: adresy IP, MAC, hasła, treść e-maili, numery kart kredytowych.
Narzędzia do czyszczenia:
# tcprewrite – zmiana adresów IP tcprewrite --infile=original.pcap --outfile=anonim.pcap \ --srcipmap=0.0.0.0/0:10.0.0.0/8 --dstipmap=0.0.0.0/0:10.0.0.0/8
| Narzędzie | Zastosowanie |
|---|---|
| capinfos | Informacje o pliku (liczba pakietów, czas, przepustowość) |
| editcap | Wycinanie, przycinanie, dzielenie, de-duplikacja |
| mergecap | Łączenie wielu plików z sortowaniem |
| reordercap | Sortowanie pakietów po czasie |
| text2pcap | Konwersja hex dump → pcap |
| rawshark | Analiza surowych danych (bez pcap) |
| tshark -r | Odczyt pól z pliku (składnia Wireshark) |
| tcpdump -r | Szybki odczyt z pliku (składnia BPF) |
| Python (scapy/dpkt/pyshark) | Programistyczna analiza i automatyzacja |
Rekomendacja: od 2025 roku domyślnie używaj pcapng. To przyszłościowy standard.
Odpowiedź: pcap to prosty format (Global Header + Packet Records) – jeden interfejs, brak metadanych. pcapng ma strukturę blokową – obsługuje wiele interfejsów, komentarze, statystyki, klucze TLS.
Odpowiedź: Do edycji plików pcap – przycinania zakresu pakietów, dzielenia, zmiany snaplen, usuwania duplikatów, modyfikacji timestampu.
Odpowiedź: mergecap łączy wiele plików w jeden (opcjonalnie sortuje po czasie). reordercap sortuje pakiety w jednym pliku według timestampu.
Odpowiedź: DSB przechowuje klucze deszyfrujące (TLS, WireGuard) dołączone do pliku – umożliwia odszyfrowanie ruchu bez osobnego pliku z kluczami.
Odpowiedź: editcap -r 50-100 wejscie.pcap wyjscie.pcap
Odpowiedź: dpkt – nie ma zależności zewnętrznych, działa na surowych bajtach.
Odpowiedź: To identyfikator formatu pcap w kolejności big-endian (0xd4c3b2a1 = little-endian). Służy do wykrywania endianness pliku.
tcpdump -i lo -c 100 -w test.pcap).capinfos test.pcap – zapisz liczbę pakietów, czas trwania, przepustowość.editcap -r 1-10 test.pcap pierwsze10.pcap – sprawdź rozmiar.editcap -s 64 test.pcap przyciete.pcap – porównaj rozmiar.mergecap -a.
Dziękujemy za uwagę. W następnej części poznamy zaawansowaną analizę protokołów – HTTP/HTTPS, DNS, DHCP, TCP – odczytywanie pól, filtrowanie i diagnostyka na podstawie przechwyconego ruchu.
Praca własna:
