`tcp.flags` begrijpen

Met het veld `tcp.flags` in Wireshark kunt u pakketten filteren op basis van de TCP-vlagbits die zijn ingesteld in de TCP-header. Deze vlaggen zijn enkele bits, maar hun combinaties zijn ongelooflijk handig om de status van een TCP-verbinding te begrijpen. Hier is een overzicht van de belangrijkste vlaggen:

* SYN (synchronisatie): Wordt gebruikt om een ​​TCP-verbinding te initiëren (het eerste pakket in de drieweg-handshake).

* ACK (erkenning): Wordt gebruikt om ontvangen gegevens of een eerder SYN-pakket te bevestigen. Bij bijna elk pakket na de SYN/ACK-uitwisseling is de ACK-vlag ingesteld.

* FIN (Voltooien): Wordt gebruikt om een ​​TCP-verbinding op een elegante manier te sluiten.

* RST (opnieuw instellen): Wordt gebruikt om een ​​TCP-verbinding abrupt te beëindigen. Geeft vaak een fout of een probleem aan.

* PSH (push): Geeft aan dat de afzender gegevens onmiddellijk naar de ontvanger stuurt. Vaak gebruikt voor interactieve toepassingen.

* URG (dringend): Geeft aan dat het veld Urgent Pointer in de TCP-header geldig is en naar urgente gegevens verwijst. Minder vaak gebruikt in moderne toepassingen.

* ECE (ECN-Echo): Wordt gebruikt voor expliciete congestiemelding (ECN) om congestie op het netwerk te signaleren.

* CWR (congestievenster verminderd): Wordt gebruikt voor expliciete congestiemelding (ECN) om aan te geven dat de afzender zijn congestievenster heeft verkleind.

Waarom is `tcp.flags` belangrijk?

Door op deze vlaggen te filteren, kunt u snel het volgende identificeren:

* Problemen met het tot stand brengen van verbindingen: Is de drievoudige handshake (SYN, SYN/ACK, ACK) met succes voltooid?

* Problemen met het beëindigen van de verbinding: Werd de verbinding netjes gesloten (FIN-uitwisseling) of abrupt (RST)?

* Heruitzendingen: Zijn er veel dubbele ACK-pakketten?

* Mogelijke aanvallen: Ongebruikelijke vlagcombinaties kunnen wijzen op pogingen om TCP-verbindingen te manipuleren.

* Congestieproblemen: Worden er ECE- of CWR-vlaggen gebruikt?

Stappen voor het oplossen van problemen met `tcp.flags` en Wireshark

Hier is een gestructureerde aanpak voor het oplossen van problemen met `tcp.flags`:

1. Verkeer genereren:

* Wireshark starten: Start Wireshark op de machine die het netwerkprobleem ondervindt of op een netwerktap als u het verkeer tussen twee apparaten controleert.

* Selecteer de juiste interface: Kies de netwerkinterface die het verkeer vervoert dat u wilt analyseren (bijvoorbeeld Ethernet, Wi-Fi).

* Opname starten: Klik op de knop "Start" (haaienvinpictogram) om te beginnen met het vastleggen van pakketten.

* Reproduceer het probleem: Terwijl Wireshark bezig is met vastleggen, reproduceert u het netwerkprobleem dat u probeert te diagnosticeren (probeer bijvoorbeeld verbinding te maken met een website, een bestand over te dragen, enz.).

* Opname stoppen: Klik op de knop "Stop" (rood vierkant pictogram) om het vastleggen van pakketten te stoppen.

2. Pas initiële filters toe (optioneel maar aanbevolen):

* `host `: Filter op het IP-adres van de client of server die bij het probleem betrokken is. Vervang `` door het werkelijke IP-adres. Voorbeeld:`host 192.168.1.100`

* `ip.addr ==`: Hetzelfde als hierboven, maar soms betrouwbaarder.

* `tcp.port ==`: Filter op een specifiek TCP-poortnummer (bijvoorbeeld 80 voor HTTP, 443 voor HTTPS, 22 voor SSH). Voorbeeld:`tcp.port ==80`

* `tcp.stream eq `: Filter op een specifiek TCP-streamnummer. U kunt het streamnummer vinden in de pakketgegevens. Dit is handig voor het isoleren van een enkele TCP-verbinding.

Deze initiële filters helpen het vastgelegde verkeer te beperken tot de relevante pakketten, waardoor analyse eenvoudiger wordt.

3. Analyseer problemen met het tot stand brengen van verbindingen (drieweg-handshake):

* Filter voor SYN-pakketten: `tcp.flags.syn ==1 en tcp.flags.ack ==0` (Dit toont SYN-pakketten zonder de ACK-vlag.)

* Zoek naar SYN/ACK-pakketten: `tcp.flags.syn ==1 en tcp.flags.ack ==1` (Dit toont SYN-pakketten waarvoor ook de ACK-vlag is ingesteld.)

* Zoek naar ACK-pakketten (het laatste deel van de handshake): `tcp.flags.ack ==1 en tcp.flags.syn ==0` (Dit toont ACK-pakketten zonder dat de SYN-vlag is ingesteld.)

Problemen oplossen op basis van dit:

* Ontbrekende SYN: Als u geen SYN-pakket van de client ziet, kan de client de server mogelijk niet bereiken (routingprobleem, firewallblokkering).

* Ontbrekende SYN/ACK: Als de client een SYN verzendt maar geen SYN/ACK ontvangt, is de server mogelijk offline, onbereikbaar of weigert de verbinding (firewall).

* Ontbrekende ACK: Als de client een SYN/ACK ontvangt maar de laatste ACK niet verzendt, kan er een probleem zijn met de netwerkconfiguratie, routering of firewall van de client.

* Opnieuw verzonden SYN-pakketten: De client verzendt meerdere keren SYN-pakketten, wat kan duiden op een probleem op het pad naar de server waardoor de eerste SYN de server niet kan bereiken.

4. Analyseer problemen met het beëindigen van de verbinding:

* Filter voor FIN-pakketten: `tcp.flags.fin ==1`

* Filter voor RST-pakketten: `tcp.flags.reset ==1`

Problemen oplossen op basis van dit:

* FIN-uitwisseling: Een sierlijke afsluiting omvat een FIN-pakket van de ene kant, een ACK voor die FIN, een FIN van de andere kant en een ACK voor die FIN. Als deze reeks onvolledig is, heeft iets het sluitingsproces onderbroken.

* RST-pakketten: Een RST-pakket duidt op een abrupte beëindiging. Zoek naar de oorzaak van de RST. Mogelijke oorzaken:

* Poort gesloten: De client of server stuurde gegevens naar een poort die niet langer luisterde.

* Verbinding geweigerd: De server weigerde de verbinding.

* Onverwachte gegevens: De ene kant ontving gegevens die zij niet verwachtte.

* Firewall: Mogelijk verbreekt een firewall de verbinding met geweld.

5. Problemen met gegevensoverdracht analyseren (na handshake):

* `tcp.analysis.retransmission`: Dit filter is een snelle manier om TCP-hertransmissies te identificeren. Een groot aantal hertransmissies duidt op pakketverlies, netwerkcongestie of andere netwerkproblemen.

* `tcp.analysis.duplicate_ack`: Dit filter identificeert dubbele ACK-pakketten, die kunnen optreden als gevolg van pakketverlies. De afzender verzendt een pakket opnieuw, en de ontvanger ACKs het originele en het opnieuw verzonden pakket, waardoor een dubbele ACK ontstaat.

* `tcp.flags.push ==1`: Filter op pakketten met de PSH-vlag ingesteld. Dit geeft aan dat de afzender dringend gegevens pusht. Hoewel dit op zichzelf meestal geen *probleem* is, kan het nuttig zijn om de gegevensstroom te begrijpen.

6. Geavanceerd filteren met `tcp.flags`

* Vlaggen combineren: Je kunt vlaggen combineren met `&&` (AND) en `||` (OR). Bijvoorbeeld:`tcp.flags.syn ==1 &&tcp.flags.reset ==1` (pakketten met zowel de SYN- als de RST-vlag ingesteld - zeer ongebruikelijk, kunnen op een aanval duiden).

* Controleren op *Elke* vlagset: `tcp.flags> 0` - Toon alle pakketten met *elke* TCP-vlag ingesteld. Dit kan handig zijn om een ​​algemeen overzicht te krijgen.

Voorbeeldscenario's

* Website kan niet laden:

1. Filter op het IP-adres van de website (`host `).

2. Controleer of er sprake is van een drieweghandshake. Als de SYN of SYN/ACK ontbreekt, onderzoek dan de netwerkconnectiviteit of de status van de server.

3. Als de handshake is voltooid, zoekt u naar HTTP GET-verzoeken en de antwoorden van de server. Zijn er heruitzendingen? Stuurt de server fouten terug (bijvoorbeeld HTTP 500-fouten)?

4. Zoek naar RST-pakketten die de verbinding mogelijk voortijdig verbreken.

* SSH-verbinding mislukt:

1. Filter op poort 22 (`tcp.port ==22`).

2. Controleer of er sprake is van een drieweghandshake.

3. Zoek naar SSH-protocolberichten. Als de handshake is voltooid maar de SSH-client en -server geen gegevens uitwisselen, is er mogelijk een probleem met de SSH-authenticatie of -configuratie.

4. Zoek naar RST-pakketten. Een resetpakket is vaak een teken van een mislukte authenticatie of een probleem met de SSH-server.

* Langzame bestandsoverdracht

1. Filter op de IP's van de client en server die de overdracht uitvoeren.

2. Zoek naar `tcp.analysis.retransmission`. Een groot aantal hertransmissies duidt op pakketverlies, netwerkcongestie of andere netwerkproblemen.

3. Zoek naar `tcp.window_size ==0`. Een venstergrootte van nul geeft aan dat de ontvanger overweldigd is en geen gegevens meer kan accepteren. De afzender zal de verzending moeten pauzeren.

Belangrijke tips

* Tijdreeksgrafiek: Gebruik Wireshark's "Statistieken -> TCP Stream Graph -> Time-Sequence Graph (Stevens)" om de TCP-verbindingsstroom te visualiseren en snel hertransmissies, hiaten en andere afwijkingen te identificeren.

* Expertinformatie: Let op het venster "Expert Info" onderaan Wireshark. Het benadrukt vaak potentiële problemen.

* Klik met de rechtermuisknop en volg de TCP-stream: Met de rechtermuisknop op een TCP-pakket klikken en "Volgen -> TCP-stream" selecteren is een goede manier om een ​​enkele TCP-verbinding te isoleren en alle pakketten in die verbinding op volgorde te bekijken.

* Leer het TCP-protocol: Een goed begrip van het TCP-protocol (vooral de drieweg-handshake en het beëindigen van de verbinding) is essentieel voor het effectief oplossen van problemen.

Door het gebruik van `tcp.flags` en deze probleemoplossingstechnieken onder de knie te krijgen, kunt u uw vermogen om netwerkproblemen te diagnosticeren en op te lossen met behulp van Wireshark aanzienlijk verbeteren. Vergeet niet om deze informatie te combineren met andere netwerkmonitoringtools en serverlogboeken voor een uitgebreid beeld van het probleem.