# 7. OSI-Schicht 4 – Transportschicht # TCP (Transmission Control Protocol) Erklärung **TCP einfach erklärt** TCP steht für **Transmission Control Protocol**. TCP ist ein **verbindungsorientiertes** und **zuverlässiges** Transportprotokoll. Es arbeitet auf der **Transportschicht** des TCP/IP-Modells und sorgt dafür, dass Daten möglichst vollständig, geordnet und fehlerfrei beim Empfänger ankommen. Typische Anwendungen mit TCP sind zum Beispiel: ```text HTTP/HTTPS SSH E-Mail Dateiübertragung Remote Desktop ``` --- **Grundidee von TCP** TCP wird verwendet, wenn Daten zuverlässig übertragen werden sollen. Das bedeutet: ```text - vor der Datenübertragung wird eine Verbindung aufgebaut - Daten werden nummeriert - empfangene Daten werden bestätigt - fehlende Daten können erneut übertragen werden - Daten werden in der richtigen Reihenfolge an die Anwendung weitergegeben ``` TCP ist dadurch zuverlässiger als UDP, hat aber mehr Verwaltungsaufwand. Merksatz: ```text TCP = verbindungsorientiert, zuverlässig und geordnet UDP = verbindungslos, schnell und mit weniger Kontrolle ``` --- **TCP arbeitet mit Ports** Eine IP-Adresse zeigt auf einen Host im Netzwerk. Beispiel: ```text 192.168.0.50 ``` Ein Port zeigt auf einen bestimmten Dienst oder eine Anwendung auf diesem Host. Beispiel: ```text 192.168.0.50:443 ``` Das bedeutet: ```text 192.168.0.50 = Host / Gerät 443 = Dienst / Anwendung, hier HTTPS ``` Typische TCP-Ports: ```text 80 = HTTP 443 = HTTPS 22 = SSH 25 = SMTP 110 = POP3 143 = IMAP 3389 = Remote Desktop ``` Merksatz: ```text IP-Adresse = welcher Host? Port = welcher Dienst? Socket = IP-Adresse + Port ``` --- **Socket bei TCP** Ein Socket ist die Kombination aus IP-Adresse und Port. Beispiel: ```text 192.168.0.50:443 ``` Bei einer TCP-Verbindung gibt es immer zwei Seiten: ```text Client-Socket: 192.168.0.20:51544 Server-Socket: 93.184.216.34:443 ``` Der Client verwendet oft einen zufälligen hohen Quellport. Der Server verwendet meistens einen bekannten festen Zielport. Eine vollständige TCP-Verbindung wird also durch diese Informationen beschrieben: ```text Quell-IP Quell-Port Ziel-IP Ziel-Port Protokoll TCP ``` --- **TCP-Verbindungsaufbau: 3-Wege-Handshake** Bevor TCP Daten überträgt, wird eine Verbindung aufgebaut. Dieser Verbindungsaufbau heißt **3-Wege-Handshake**. Dabei tauschen Client und Server Kontrollinformationen aus. Ablauf: ```text Client Server 1. SYN ---------------------> Verbindungswunsch 2. SYN-ACK <------------------ Verbindungswunsch bestätigt 3. ACK ---------------------> Bestätigung zurück Verbindung steht ``` --- **Was bedeutet SYN?** SYN ist die Abkürzung für: ```text Synchronize ``` Auf Deutsch: ```text synchronisieren ``` Beim TCP-Verbindungsaufbau bedeutet SYN: ```text Der Client möchte eine neue TCP-Verbindung starten und seine Start-Sequenznummer mit dem Server synchronisieren. ``` SYN ist also nicht einfach nur „Hallo“, sondern enthält auch technische Informationen für den Start der Verbindung. --- **Was bedeutet SYN-ACK?** SYN-ACK besteht aus zwei Teilen: ```text SYN = Server möchte ebenfalls seine Start-Sequenznummer synchronisieren ACK = Server bestätigt den SYN des Clients ``` Der Server sagt damit vereinfacht: ```text Ich habe deinen Verbindungswunsch erhalten. Ich bin bereit. Hier ist meine eigene Start-Sequenznummer. ``` --- **Was bedeutet ACK?** ACK steht für: ```text Acknowledgement ``` Auf Deutsch: ```text Bestätigung ``` Beim dritten Schritt bestätigt der Client die Antwort des Servers. Danach gilt: ```text Die TCP-Verbindung ist aufgebaut. Daten können übertragen werden. ``` Merksatz: ```text SYN = Verbindungswunsch + Start-Sequenznummer synchronisieren SYN-ACK = Verbindungswunsch bestätigen + eigene Start-Sequenznummer senden ACK = Bestätigung zurücksenden ``` --- **Sequenznummer ist keine Portnummer** Eine Sequenznummer ist nicht dasselbe wie eine Portnummer. Eine **Portnummer** sagt: ```text Welcher Dienst oder welches Programm ist gemeint? ``` Eine **Sequenznummer** sagt: ```text An welcher Stelle im TCP-Datenstrom befinden sich diese Daten? ``` Merksatz: ```text Portnummer = welcher Dienst? Sequenznummer = welche Stelle im Datenstrom? ``` Oder einfacher: ```text Portnummer ist wie die Türnummer eines Dienstes. Sequenznummer ist wie die Position der Daten im Datenstrom. ``` --- **Was macht die Sequenznummer bei TCP?** TCP nummeriert nicht einfach nur einzelne Pakete wie „Paket 1, Paket 2, Paket 3“. Technisch genauer: ```text TCP nummeriert die Bytes im Datenstrom. ``` Dadurch weiß der Empfänger: ```text - wo ein empfangenes TCP-Segment im Datenstrom beginnt - ob Daten in der richtigen Reihenfolge angekommen sind - ob Daten fehlen - ob Daten doppelt angekommen sind ``` Ein TCP-Segment enthält eine Sequenznummer. Diese Sequenznummer zeigt, an welcher Position im Datenstrom die enthaltenen Daten beginnen. --- **Einfaches Beispiel für Sequenznummern** ```text Segment 1: Sequenznummer 1000, enthält 500 Byte Segment 2: Sequenznummer 1500, enthält 500 Byte Segment 3: Sequenznummer 2000, enthält 500 Byte ``` Das bedeutet: ```text Segment 1 beginnt bei Byte 1000. Segment 2 beginnt bei Byte 1500. Segment 3 beginnt bei Byte 2000. ``` Wenn alles korrekt ankommt, kann der Empfänger die Daten in der richtigen Reihenfolge zusammensetzen. --- **Was passiert, wenn Daten verloren gehen?** Angenommen, Segment 2 geht verloren: ```text Segment 1 kommt an: Sequenznummer 1000 Segment 2 fehlt: Sequenznummer 1500 Segment 3 kommt an: Sequenznummer 2000 ``` Der Empfänger merkt: ```text Ich habe Daten ab 1000 bekommen. Danach müsste eigentlich 1500 kommen. Jetzt kommt aber schon 2000. Also fehlt der Bereich ab 1500. ``` TCP erkennt dadurch, dass ein Teil der Daten fehlt. Die fehlenden Daten können dann erneut übertragen werden. --- **ACK = Bestätigung empfangener Daten** Mit einem ACK bestätigt der Empfänger, welche Daten korrekt angekommen sind. Vereinfacht gesagt: ```text ACK 1500 = Ich habe alles bis vor 1500 korrekt erhalten. Bitte sende als Nächstes die Daten ab 1500. ``` Wenn Daten fehlen, bestätigt der Empfänger nicht einfach alles als vollständig. Stattdessen signalisiert er sinngemäß: ```text Ich erwarte weiterhin die Daten ab dieser Sequenznummer. ``` Dadurch erkennt der Sender, dass Daten erneut übertragen werden müssen. --- **Muss TCP komplett warten, wenn ein Segment fehlt?** Nicht unbedingt. Später angekommene Daten können zwischengespeichert werden. Beispiel: ```text Segment 1 kommt an. Segment 2 fehlt. Segment 3 kommt schon an. ``` TCP kann Segment 3 intern speichern. Wichtig ist aber: ```text An die Anwendung werden die Daten erst in der richtigen Reihenfolge weitergegeben. ``` Das bedeutet: ```text Die Anwendung bekommt Segment 3 nicht vor Segment 2. Erst wenn die fehlenden Daten angekommen sind, werden die Daten geordnet weitergegeben. ``` Dadurch sieht die Anwendung einen zuverlässigen und geordneten Datenstrom. --- **Warum ist TCP zuverlässig?** TCP gilt als zuverlässig, weil es mehrere Kontrollmechanismen verwendet. Dazu gehören: ```text - Verbindungsaufbau durch 3-Wege-Handshake - Sequenznummern - ACK-Bestätigungen - erneute Übertragung verlorener Daten - Reihenfolgekontrolle - Erkennung doppelt empfangener Daten - Flusskontrolle ``` Dadurch kann TCP sicherstellen, dass Daten vollständig und in der richtigen Reihenfolge beim Empfänger ankommen. --- **Flusskontrolle bei TCP** TCP verwendet Flusskontrolle, damit ein schneller Sender einen langsameren Empfänger nicht überfordert. Der Empfänger kann dem Sender mitteilen, wie viele Daten er aktuell aufnehmen kann. Das nennt man vereinfacht: ```text Empfangsfenster ``` Wenn der Empfänger nur wenig Speicher frei hat, kann er dem Sender signalisieren: ```text Sende langsamer oder warte kurz. ``` Dadurch wird verhindert, dass der Empfänger mit zu vielen Daten überlastet wird. --- **TCP-Verbindungsabbau** Eine TCP-Verbindung wird nicht einfach abrupt beendet, sondern kontrolliert geschlossen. Dafür werden unter anderem FIN- und ACK-Nachrichten verwendet. Vereinfacht: ```text Eine Seite sagt: Ich möchte die Verbindung beenden. Die andere Seite bestätigt das. Danach kann auch die andere Seite ihre Richtung schließen. ``` Typische Steuerbits beim Verbindungsabbau: ```text FIN = Verbindung geordnet beenden ACK = Bestätigung ``` Merksatz: ```text SYN = Verbindung aufbauen FIN = Verbindung beenden ACK = bestätigen ``` --- **TCP im Vergleich zu UDP** TCP: ```text - verbindungsorientiert - zuverlässig - geordnete Datenübertragung - Bestätigungen durch ACKs - erneute Übertragung verlorener Daten - mehr Verwaltungsaufwand ``` UDP: ```text - verbindungslos - geringer Verwaltungsaufwand - keine eingebaute Zustellgarantie - keine eingebaute Reihenfolgekontrolle - keine eingebaute erneute Übertragung - oft latenzärmer als TCP ``` TCP wird verwendet, wenn Zuverlässigkeit wichtig ist. UDP wird häufig verwendet, wenn geringe Verzögerung wichtiger ist als vollständige Kontrolle. --- **Beispiel: TCP beim Webseitenaufruf** Wenn ein Client eine HTTPS-Webseite aufruft, passiert vereinfacht Folgendes: ```text 1. Client möchte Website aufrufen. 2. Client baut TCP-Verbindung zum Server-Port 443 auf. 3. TCP führt den 3-Wege-Handshake aus. 4. Danach werden Daten übertragen. 5. TCP nummeriert die Daten mit Sequenznummern. 6. Der Empfänger bestätigt empfangene Daten mit ACKs. 7. Fehlende Daten werden erneut übertragen. 8. Die Anwendung erhält die Daten in der richtigen Reihenfolge. ``` Beispiel: ```text Client: 192.168.0.20:51544 Server: 93.184.216.34:443 Protokoll: TCP ``` --- **Wichtige TCP-Begriffe** ```text TCP = Transmission Control Protocol SYN = Synchronize ACK = Acknowledgement FIN = Finish Port = Dienstadresse auf einem Host Socket = IP-Adresse + Port Sequenznummer = Position der Daten im TCP-Datenstrom 3-Wege-Handshake = Verbindungsaufbau bei TCP ``` --- **IHK-sichere Kurzformulierung** TCP ist ein verbindungsorientiertes und zuverlässiges Transportprotokoll. Vor der Datenübertragung wird durch den 3-Wege-Handshake eine Verbindung aufgebaut. TCP verwendet Sequenznummern, um die Reihenfolge der übertragenen Daten im Datenstrom festzulegen. Mit ACKs bestätigt der Empfänger korrekt erhaltene Daten. Fehlende Daten können erkannt und erneut übertragen werden. Dadurch stellt TCP eine geordnete und zuverlässige Datenübertragung bereit. --- **Merksätze** ```text TCP = verbindungsorientiert, zuverlässig und geordnet ``` ```text SYN = Verbindung starten SYN-ACK = Verbindung bestätigen und eigene Startnummer senden ACK = Bestätigung ``` ```text Portnummer = welcher Dienst? Sequenznummer = welche Stelle im Datenstrom? ``` ```text Sequenznummern helfen TCP zu erkennen, ob Daten fehlen, doppelt angekommen sind oder in falscher Reihenfolge eintreffen. ``` ```text ACK bestätigt, bis wohin Daten korrekt empfangen wurden. ``` ```text Fehlende Daten werden erneut übertragen. Später angekommene Daten können zwischengespeichert werden. An die Anwendung geht alles erst in der richtigen Reihenfolge. ``` ```text SYN = Verbindung aufbauen FIN = Verbindung beenden ACK = bestätigen ``` # UDP (User Datagram Protocol) Erklärung **UDP einfach erklärt** UDP steht für **User Datagram Protocol**. UDP ist ein **verbindungsloses** Transportprotokoll. Es arbeitet auf der **Transportschicht** des TCP/IP-Modells und wird verwendet, wenn Daten schnell und mit möglichst wenig Verwaltungsaufwand übertragen werden sollen. UDP ist einfacher aufgebaut als TCP. Dafür bietet UDP aber keine eingebaute Garantie, dass Daten ankommen, vollständig sind oder in der richtigen Reihenfolge eintreffen. Typische Anwendungen mit UDP sind zum Beispiel: ```text id="uw4t0s" DNS DHCP VoIP Video-Streaming Audio-Streaming Online-Gaming QUIC / HTTP/3 ``` --- **Grundidee von UDP** UDP wird verwendet, wenn eine schnelle und einfache Datenübertragung wichtiger ist als vollständige Kontrolle. Das bedeutet: ```text id="qjkbh4" - keine feste Verbindung vor der Datenübertragung - kein 3-Wege-Handshake - keine eingebaute Zustellgarantie - keine eingebaute Reihenfolgekontrolle - keine automatische erneute Übertragung verlorener Daten - geringer Verwaltungsaufwand ``` UDP sendet Daten einfach los. Ob die Gegenseite erreichbar ist oder ob die Daten vollständig ankommen, wird von UDP selbst nicht zuverlässig kontrolliert. Merksatz: ```text id="r2d2tr" UDP = verbindungslos, einfach und schnell TCP = verbindungsorientiert, zuverlässig und geordnet ``` --- **UDP arbeitet mit Ports** Auch UDP verwendet Ports, genau wie TCP. Eine IP-Adresse zeigt auf einen Host im Netzwerk. Beispiel: ```text id="mmwunq" 192.168.0.50 ``` Ein Port zeigt auf einen bestimmten Dienst oder eine Anwendung auf diesem Host. Beispiel: ```text id="xm2x76" 192.168.0.50:53 ``` Das bedeutet: ```text id="us9fs8" 192.168.0.50 = Host / Gerät 53 = Dienst / Anwendung, hier DNS ``` Typische UDP-Ports: ```text id="c7t24c" 53 = DNS 67 = DHCP Server 68 = DHCP Client 123 = NTP 500 = IKE / IPsec 1194 = OpenVPN 51820 = WireGuard 443 = QUIC / HTTP/3 ``` Wichtig: ```text id="liglsp" Ein Port kann bei TCP und UDP unterschiedlich verwendet werden. ``` Beispiel: ```text id="b8gdwc" TCP 443 = HTTPS über TCP UDP 443 = QUIC / HTTP/3 ``` Merksatz: ```text id="rxre7n" IP-Adresse = welcher Host? Port = welcher Dienst? Socket = IP-Adresse + Port ``` --- **Socket bei UDP** Ein Socket ist die Kombination aus IP-Adresse und Port. Beispiel: ```text id="juvi9v" 192.168.0.50:53 ``` Bei UDP kann ein Datenpaket von einem Quell-Socket zu einem Ziel-Socket gesendet werden. Beispiel: ```text id="khkoyw" Client-Socket: 192.168.0.20:53000 Server-Socket: 192.168.0.1:53 ``` Das bedeutet: ```text id="ro5p0x" Client fragt von Port 53000 aus einen DNS-Server auf Port 53 an. ``` Eine UDP-Kommunikation wird also durch diese Informationen beschrieben: ```text id="cvvu8u" Quell-IP Quell-Port Ziel-IP Ziel-Port Protokoll UDP ``` --- **UDP hat keinen Verbindungsaufbau** Bei TCP gibt es vor der Datenübertragung einen 3-Wege-Handshake. Bei UDP gibt es diesen Verbindungsaufbau nicht. TCP: ```text id="fjeq6e" Client Server 1. SYN ---------------------> 2. SYN-ACK <------------------ 3. ACK ---------------------> Verbindung steht ``` UDP: ```text id="ocsnv9" Client Server Datenpaket ------------------> Keine vorherige Verbindung Keine SYN-Nachricht Kein SYN-ACK Kein ACK durch UDP selbst ``` UDP sendet also direkt ein Datagramm an den Empfänger. Merksatz: ```text id="h4fwtv" TCP fragt vorher: Darf ich eine Verbindung aufbauen? UDP sendet direkt los. ``` --- **Was ist ein UDP-Datagramm?** Die Dateneinheit bei UDP nennt man **Datagramm**. Ein UDP-Datagramm enthält unter anderem: ```text id="x9raek" - Quellport - Zielport - Länge - Prüfsumme - Nutzdaten ``` UDP ist dadurch sehr schlank aufgebaut. Wichtig: ```text id="k3i579" UDP nummeriert die Daten nicht wie TCP mit Sequenznummern. ``` Deshalb kann UDP selbst nicht zuverlässig erkennen, ob ein Datagramm fehlt oder in falscher Reihenfolge angekommen ist. --- **UDP hat keine Sequenznummern wie TCP** TCP verwendet Sequenznummern, um die Position der Daten im Datenstrom festzulegen. UDP macht das nicht. TCP: ```text id="oydme1" Segment 1: Sequenznummer 1000 Segment 2: Sequenznummer 1500 Segment 3: Sequenznummer 2000 ``` UDP: ```text id="rfk6ec" Datagramm 1 wird gesendet. Datagramm 2 wird gesendet. Datagramm 3 wird gesendet. UDP selbst merkt sich keine Reihenfolge. ``` Wenn ein UDP-Datagramm verloren geht, wird es von UDP nicht automatisch erneut angefordert. Wenn UDP-Datagramme in falscher Reihenfolge ankommen, sortiert UDP sie nicht automatisch. Merksatz: ```text id="z5xqmv" TCP kontrolliert die Reihenfolge. UDP sendet einzelne Datagramme ohne Reihenfolgegarantie. ``` --- **UDP hat keine eingebaute Zustellgarantie** UDP garantiert nicht, dass ein Datagramm beim Empfänger ankommt. Ein UDP-Datagramm kann unterwegs verloren gehen, zum Beispiel durch: ```text id="tpyoxq" - Netzwerküberlastung - Paketverlust - Routing-Probleme - Firewall-Regeln - fehlerhafte Übertragung ``` UDP selbst sendet verlorene Datagramme nicht automatisch erneut. Das bedeutet: ```text id="j117zs" Wenn ein UDP-Datagramm verloren geht, merkt UDP selbst das nicht zuverlässig und fordert es nicht automatisch erneut an. ``` Wenn eine Anwendung trotzdem Zuverlässigkeit braucht, muss sie diese selbst oberhalb von UDP einbauen. Beispiele dafür sind: ```text id="mvkcxj" - eigene Bestätigungen - eigene Sequenznummern - eigene Wiederholungen - Fehlerkorrektur auf Anwendungsebene ``` --- **UDP hat keine eingebaute Reihenfolgekontrolle** UDP garantiert nicht, dass Datagramme in der gesendeten Reihenfolge ankommen. Beispiel: ```text id="lfyv0x" Gesendet: Datagramm 1 Datagramm 2 Datagramm 3 Angekommen: Datagramm 1 Datagramm 3 Datagramm 2 ``` UDP sortiert diese Datagramme nicht automatisch. Wenn die Reihenfolge wichtig ist, muss die Anwendung selbst dafür sorgen. Beispiel: ```text id="zx6bun" Eine Anwendung kann eigene Nummern in die Nutzdaten schreiben, um die Reihenfolge später selbst zu prüfen. ``` Merksatz: ```text id="trkhmn" UDP liefert Datagramme so ab, wie sie ankommen. UDP sortiert nicht automatisch. ``` --- **UDP hat weniger Verwaltungsaufwand als TCP** UDP hat weniger Verwaltungsaufwand, weil es keinen Verbindungsaufbau, keine Sequenznummern, keine ACKs und keine automatische Wiederholung verlorener Daten gibt. Dadurch ist UDP oft: ```text id="oxqyll" - einfacher - schneller beim Start - latenzärmer - ressourcenschonender ``` Wichtig: ```text id="fb1xle" UDP ist nicht automatisch immer schneller im Sinne von höherer Datenrate. ``` Besser formuliert: ```text id="u1y6bf" UDP hat weniger Verwaltungsaufwand als TCP und kann dadurch schneller bzw. latenzärmer sein. ``` Das ist besonders bei Anwendungen wichtig, bei denen Echtzeit wichtiger ist als perfekte Vollständigkeit. --- **Warum nutzt man UDP trotz fehlender Garantie?** UDP wird genutzt, weil bei manchen Anwendungen verlorene Daten weniger schlimm sind als Verzögerungen. Beispiel VoIP: ```text id="b9dwji" Bei einem Telefonat ist es besser, wenn ein kleines Audiostück kurz fehlt, als wenn die Sprache stark verzögert ankommt. ``` Beispiel Online-Gaming: ```text id="v8bj6p" Bei schnellen Positionsdaten ist es oft besser, aktuelle Daten zu bekommen, als alte verlorene Daten nachträglich zu übertragen. ``` Beispiel Streaming: ```text id="b0ak7g" Bei Live-Video ist geringe Verzögerung wichtiger als jedes einzelne Paket nachträglich zu retten. ``` Merksatz: ```text id="s5lpaf" UDP wird häufig verwendet, wenn Aktualität wichtiger ist als vollständige Nachlieferung. ``` --- **Beispiel: DNS mit UDP** DNS verwendet sehr häufig UDP auf Port 53. Ablauf vereinfacht: ```text id="dg9sll" 1. Client möchte wissen, welche IP-Adresse zu einer Domain gehört. 2. Client sendet eine DNS-Anfrage per UDP an Port 53. 3. DNS-Server antwortet per UDP. 4. Die Antwort enthält die passende IP-Adresse. ``` Beispiel: ```text id="b7il9z" Client: 192.168.0.20:53000 DNS-Server: 192.168.0.1:53 Protokoll: UDP ``` Warum UDP hier sinnvoll ist: ```text id="bhv68v" - DNS-Anfragen sind meist klein - eine Verbindung vorher aufzubauen wäre zusätzlicher Aufwand - bei Verlust kann die Anfrage einfach erneut gestellt werden ``` Wichtig: ```text id="id0weu" DNS kann auch TCP verwenden, zum Beispiel bei größeren Antworten oder Zonentransfers. ``` --- **Beispiel: VoIP mit UDP** Bei VoIP werden Sprachdaten in kleinen Paketen übertragen. UDP eignet sich hier gut, weil geringe Verzögerung besonders wichtig ist. Beispiel: ```text id="bpo809" Sprecher → Sprachpakete → Netzwerk → Empfänger ``` Wenn ein kleines Sprachpaket verloren geht, ist das meist weniger schlimm als eine große Verzögerung. Deshalb ist bei VoIP oft wichtiger: ```text id="tkeck3" geringe Latenz statt vollständige Nachlieferung ``` --- **Beispiel: Online-Gaming mit UDP** Online-Spiele übertragen häufig Positionsdaten, Bewegungen und Zustände. Beispiel: ```text id="zlhpln" Spielerposition Blickrichtung Bewegung Aktionen ``` Wenn ein altes Positionspaket verloren geht, ist es oft nicht sinnvoll, es später noch nachzuliefern. Wichtiger ist: ```text id="mvix7g" Der aktuelle Zustand soll möglichst schnell ankommen. ``` Deshalb wird für solche Echtzeitdaten häufig UDP genutzt. --- **QUIC und HTTP/3 nutzen UDP** QUIC ist ein modernes Transportprotokoll, das auf UDP basiert. HTTP/3 verwendet QUIC. Vereinfacht: ```text id="bp3znh" HTTP/3 läuft über QUIC. QUIC läuft über UDP. UDP läuft über IP. ``` Wichtig: ```text id="f7w5w8" QUIC nutzt UDP als Grundlage, baut aber eigene Funktionen für Zuverlässigkeit, Verschlüsselung und Verbindungssteuerung ein. ``` Das bedeutet: ```text id="h8lbmz" UDP selbst ist einfach und verbindungslos. QUIC ergänzt darauf zusätzliche moderne Funktionen. ``` --- **UDP und Firewall** Firewalls können UDP-Verkehr filtern, genau wie TCP-Verkehr. Dabei werden zum Beispiel geprüft: ```text id="kil5ai" - Quell-IP - Ziel-IP - Quellport - Zielport - Protokoll UDP ``` Da UDP keine feste Verbindung wie TCP aufbaut, ist die Zustandsverfolgung schwieriger. Eine Stateful Firewall kann sich aber trotzdem merken, dass ein interner Client ein UDP-Datagramm nach außen gesendet hat. Beispiel: ```text id="ov5tx8" Client sendet DNS-Anfrage an DNS-Server. Firewall merkt sich diese Anfrage kurzzeitig. DNS-Antwort darf zurück. Unerwartete UDP-Pakete von außen werden blockiert. ``` Merksatz: ```text id="sdoksc" Auch UDP kann von einer Stateful Firewall verfolgt werden, aber ohne echten TCP-Verbindungszustand. ``` --- **UDP und NAT/PAT** Auch UDP kann über NAT/PAT ins Internet gehen. Beispiel: ```text id="moxl85" Interner Client: 192.168.0.20:53000 Öffentliche IP: 84.10.20.30:40001 DNS-Server: 1.1.1.1:53 ``` Die Firewall bzw. der Router merkt sich die Zuordnung: ```text id="gmefwr" 192.168.0.20:53000 → 84.10.20.30:40001 ``` Wenn die Antwort vom DNS-Server zurückkommt, weiß der Router: ```text id="xat6qe" Diese Antwort gehört zurück an 192.168.0.20:53000. ``` Wichtig: ```text id="vrpgqo" Bei UDP sind solche NAT-Zuordnungen meist zeitlich begrenzt, weil es keine dauerhaft aufgebaute Verbindung wie bei TCP gibt. ``` --- **UDP im Vergleich zu TCP** TCP: ```text id="eh3mx2" - verbindungsorientiert - 3-Wege-Handshake - zuverlässig - Sequenznummern - ACK-Bestätigungen - erneute Übertragung verlorener Daten - Reihenfolgekontrolle - mehr Verwaltungsaufwand ``` UDP: ```text id="mdpw5m" - verbindungslos - kein 3-Wege-Handshake - keine eingebaute Zustellgarantie - keine eingebaute Reihenfolgekontrolle - keine automatische erneute Übertragung - weniger Verwaltungsaufwand - oft latenzärmer ``` Merksatz: ```text id="z5zccy" TCP kontrolliert stärker. UDP ist schlanker und direkter. ``` --- **Wann verwendet man TCP?** TCP verwendet man, wenn Daten zuverlässig und vollständig ankommen müssen. Beispiele: ```text id="ofkz4y" - Webseiten über HTTP/HTTPS - Dateiübertragung - SSH - E-Mail - Remote Desktop ``` Hier wäre es schlecht, wenn Daten fehlen oder in falscher Reihenfolge bei der Anwendung ankommen. --- **Wann verwendet man UDP?** UDP verwendet man häufig, wenn geringe Verzögerung wichtiger ist als vollständige Kontrolle. Beispiele: ```text id="yhm18n" - DNS - DHCP - VoIP - Live-Streaming - Online-Gaming - NTP - VPN-Protokolle wie WireGuard - QUIC / HTTP/3 ``` Hier ist es oft besser, schnell weiterzumachen, statt verlorene alte Daten nachzuliefern. --- **Ist UDP unsicherer als TCP?** UDP ist nicht automatisch „unsicherer“ als TCP. UDP hat nur weniger eingebaute Kontrollfunktionen. Sicherheit hängt vor allem davon ab: ```text id="qcspw6" - welches Anwendungsprotokoll verwendet wird - ob Verschlüsselung eingesetzt wird - wie die Firewall konfiguriert ist - ob der Dienst korrekt abgesichert ist ``` Beispiel: ```text id="fi58m3" QUIC nutzt UDP, kann aber trotzdem verschlüsselte Kommunikation ermöglichen. ``` UDP bedeutet also nicht automatisch unsicher. Es bedeutet nur: ```text id="b3e9op" UDP selbst garantiert weniger als TCP. ``` --- **Wichtige UDP-Begriffe** ```text id="xii0zl" UDP = User Datagram Protocol Datagramm = einzelne UDP-Dateneinheit Port = Dienstadresse auf einem Host Socket = IP-Adresse + Port Quellport = Port des sendenden Systems Zielport = Port des empfangenden Dienstes Prüfsumme = einfache Fehlererkennung im UDP-Datagramm ``` --- **IHK-sichere Kurzformulierung** UDP ist ein verbindungsloses Transportprotokoll mit geringem Verwaltungsaufwand. Im Gegensatz zu TCP baut UDP vor der Datenübertragung keine Verbindung auf und bietet keine eingebaute Garantie für Zustellung, Reihenfolge oder erneute Übertragung verlorener Daten. Dadurch ist UDP besonders für Anwendungen geeignet, bei denen geringe Verzögerung wichtiger ist als vollständige Kontrolle, zum Beispiel DNS, VoIP, Streaming oder Online-Gaming. --- **Merksätze** ```text id="vkybjj" UDP = verbindungslos, einfach und mit wenig Verwaltungsaufwand ``` ```text id="bxkqfb" UDP sendet direkt los. TCP baut vorher eine Verbindung auf. ``` ```text id="xg0rxw" UDP garantiert nicht, dass Datagramme ankommen, in richtiger Reihenfolge ankommen oder erneut übertragen werden. ``` ```text id="uw4sfa" UDP ist oft latenzärmer als TCP, aber nicht automatisch immer schneller in jeder Situation. ``` ```text id="gp5pfr" TCP = Zuverlässigkeit und Kontrolle UDP = Geschwindigkeit und geringer Verwaltungsaufwand ``` ```text id="kgukso" Wenn UDP Zuverlässigkeit braucht, muss die Anwendung diese selbst einbauen. ``` ```text id="hqqhqr" DNS, VoIP, Streaming und Online-Gaming sind typische Beispiele für UDP. ``` # TCP versus UDP TCP und UDP sind beide Transportprotokolle. Sie arbeiten auf der Transportschicht und sorgen dafür, dass Daten zwischen Anwendungen auf verschiedenen Geräten übertragen werden können. Der wichtigste Unterschied ist: TCP baut vor der Datenübertragung eine Verbindung auf. UDP sendet Daten ohne vorherigen Verbindungsaufbau direkt los. --- **TCP kurz erklärt** TCP steht für **Transmission Control Protocol**. TCP ist: - verbindungsorientiert - zuverlässig - geordnet - kontrolliert - mit mehr Verwaltungsaufwand verbunden Bei TCP wird vor der Übertragung der eigentlichen Nutzdaten zuerst eine Verbindung aufgebaut. Dieser Verbindungsaufbau heißt **3-Wege-Handshake**. Client Server 1. SYN ---------------------> Verbindungswunsch 2. SYN-ACK <------------------ Bestätigung + eigene Start-Sequenznummer 3. ACK ---------------------> Bestätigung Danach ist die TCP-Verbindung aufgebaut. Erst danach werden die eigentlichen Nutzdaten übertragen. Wichtig: Nicht ACK ist der erste Schritt. Der erste Schritt ist SYN. ACK ist die Bestätigung im dritten Schritt. --- **Was bedeutet SYN bei TCP?** SYN steht für: Synchronize Auf Deutsch: synchronisieren SYN bedeutet beim TCP-Verbindungsaufbau: Der Client möchte eine neue TCP-Verbindung starten und seine Start-Sequenznummer mit dem Server synchronisieren. SYN ist also der Verbindungswunsch und gleichzeitig der Start der Synchronisation der Sequenznummern. --- **Was bedeutet SYN-ACK bei TCP?** SYN-ACK besteht aus zwei Teilen: SYN = Server möchte ebenfalls seine Start-Sequenznummer synchronisieren ACK = Server bestätigt den SYN des Clients Der Server sagt damit vereinfacht: Ich habe deinen Verbindungswunsch erhalten. Ich bin bereit. Hier ist meine eigene Start-Sequenznummer. --- **Was bedeutet ACK bei TCP?** ACK steht für: Acknowledgement Auf Deutsch: Bestätigung Mit ACK bestätigt eine Seite, dass bestimmte Daten oder Steuerinformationen angekommen sind. Beim 3-Wege-Handshake bestätigt der Client mit ACK die Antwort des Servers. Merksatz: SYN = Verbindung starten und Sequenznummer synchronisieren SYN-ACK = Verbindung bestätigen und eigene Startnummer senden ACK = Bestätigung zurücksenden --- **UDP kurz erklärt** UDP steht für **User Datagram Protocol**. UDP ist: - verbindungslos - einfach - schnell bzw. oft latenzärmer - mit wenig Verwaltungsaufwand verbunden - ohne eingebaute Zustellgarantie - ohne eingebaute Reihenfolgekontrolle - ohne automatische erneute Übertragung verlorener Daten Bei UDP gibt es keinen 3-Wege-Handshake. Client Server Daten -----------------------> Kein SYN Kein SYN-ACK Kein verbindungsaufbauendes ACK UDP sendet Datagramme direkt los. UDP selbst prüft nicht zuverlässig, ob die Gegenseite bereit ist oder ob die Daten vollständig angekommen sind. --- **Nutzdaten bei TCP und UDP** Nutzdaten sind die eigentlichen Inhalte, die eine Anwendung übertragen möchte. Beispiele: - Webseiteninhalte - Dateien - Sprache - Videodaten - DNS-Anfragen - Spielinformationen Bei TCP gilt: Erst Verbindungsaufbau, dann Nutzdaten. Bei UDP gilt: Kein Verbindungsaufbau, Nutzdaten werden direkt als Datagramm gesendet. --- **Sequenznummern bei TCP** TCP verwendet Sequenznummern. Eine Sequenznummer ist keine Portnummer. Portnummer = welcher Dienst? Sequenznummer = welche Stelle im Datenstrom? TCP nummeriert technisch gesehen die Bytes im Datenstrom. Dadurch kann der Empfänger erkennen: - welche Daten angekommen sind - ob Daten fehlen - ob Daten doppelt angekommen sind - ob Daten in falscher Reihenfolge angekommen sind Beispiel: Segment 1: Sequenznummer 1000, enthält 500 Byte Segment 2: Sequenznummer 1500, enthält 500 Byte Segment 3: Sequenznummer 2000, enthält 500 Byte Wenn Segment 2 fehlt, merkt TCP: Nach 1000 müsste 1500 kommen. Wenn schon 2000 kommt, fehlt der Bereich ab 1500. Fehlende Daten können dann erneut übertragen werden. --- **UDP hat keine TCP-Sequenznummern** UDP nummeriert die Daten nicht wie TCP mit Sequenznummern. UDP sendet einzelne Datagramme. Datagramm 1 wird gesendet. Datagramm 2 wird gesendet. Datagramm 3 wird gesendet. UDP selbst merkt sich dabei keine Reihenfolge. Wenn ein Datagramm verloren geht, fordert UDP es nicht automatisch erneut an. Wenn Datagramme in falscher Reihenfolge ankommen, sortiert UDP sie nicht automatisch. --- **Zuverlässigkeit** TCP ist zuverlässig, weil es mehrere Kontrollmechanismen verwendet: - Verbindungsaufbau durch 3-Wege-Handshake - Sequenznummern - ACK-Bestätigungen - erneute Übertragung verlorener Daten - Reihenfolgekontrolle - Erkennung doppelt empfangener Daten - Flusskontrolle UDP hat diese Zuverlässigkeit nicht eingebaut. UDP garantiert nicht: - dass Daten ankommen - dass Daten vollständig ankommen - dass Daten in der richtigen Reihenfolge ankommen - dass verlorene Daten erneut übertragen werden Wenn eine Anwendung über UDP trotzdem Zuverlässigkeit benötigt, muss sie diese selbst einbauen. Beispiele: - eigene Bestätigungen - eigene Sequenznummern - eigene Wiederholungen - Fehlerkorrektur auf Anwendungsebene --- **Geschwindigkeit und Verwaltungsaufwand** TCP hat mehr Verwaltungsaufwand, weil es Verbindungen aufbaut, Daten bestätigt, Reihenfolgen prüft und verlorene Daten erneut überträgt. UDP hat weniger Verwaltungsaufwand, weil es diese Funktionen nicht eingebaut hat. Deshalb ist UDP oft latenzärmer. Wichtig: UDP ist nicht automatisch immer schneller im Sinne von höherer Datenrate. UDP hat aber weniger Verwaltungsaufwand und kann dadurch schneller reagieren. Besser formuliert: UDP ist oft latenzärmer als TCP, weil es keinen Verbindungsaufbau und weniger Kontrollmechanismen hat. --- **Typische Anwendungen für TCP** TCP wird verwendet, wenn Daten zuverlässig und vollständig ankommen müssen. Beispiele: - HTTP/HTTPS über TCP - SSH - E-Mail - Dateiübertragung - Remote Desktop - Datenbankverbindungen Hier wäre es problematisch, wenn Daten fehlen oder in falscher Reihenfolge bei der Anwendung ankommen. Beispiel: Bei einer Dateiübertragung darf kein Teil der Datei fehlen. Bei SSH müssen Befehle korrekt und in richtiger Reihenfolge ankommen. Bei Webseiten sollen Inhalte vollständig übertragen werden. --- **Typische Anwendungen für UDP** UDP wird häufig verwendet, wenn geringe Verzögerung wichtiger ist als vollständige Kontrolle. Beispiele: - DNS - DHCP - VoIP - Live-Streaming - Online-Gaming - NTP - WireGuard - QUIC / HTTP/3 Beispiel VoIP: Bei einem Telefonat ist es besser, wenn ein kleines Audiostück kurz fehlt, als wenn die Sprache stark verzögert ankommt. Beispiel Online-Gaming: Bei schnellen Positionsdaten ist der aktuelle Zustand wichtiger als ein altes verlorenes Paket nachträglich zu übertragen. --- **DNS als Beispiel für UDP** DNS nutzt sehr häufig UDP auf Port 53. Ablauf vereinfacht: 1. Client fragt per UDP beim DNS-Server an. 2. DNS-Server antwortet per UDP. 3. Die Antwort enthält die passende IP-Adresse zur Domain. Beispiel: Client: 192.168.0.20:53000 DNS-Server: 192.168.0.1:53 Protokoll: UDP Warum UDP hier sinnvoll ist: - DNS-Anfragen sind meist klein. - Ein TCP-Verbindungsaufbau wäre zusätzlicher Aufwand. - Bei Verlust kann die Anfrage einfach erneut gestellt werden. Wichtig: DNS kann auch TCP verwenden, zum Beispiel bei größeren Antworten oder Zonentransfers. --- **QUIC und HTTP/3** QUIC ist ein modernes Transportprotokoll, das auf UDP basiert. HTTP/3 läuft über QUIC. QUIC läuft über UDP. UDP läuft über IP. Wichtig: UDP selbst ist einfach und verbindungslos. QUIC baut darauf eigene Funktionen für Verbindung, Zuverlässigkeit und Verschlüsselung auf. Das bedeutet: Nur weil UDP selbst keine TCP-Zuverlässigkeit bietet, kann ein Protokoll oberhalb von UDP trotzdem eigene Kontrollmechanismen einbauen. --- **TCP und UDP mit Ports** Sowohl TCP als auch UDP verwenden Ports. IP-Adresse = welcher Host? Port = welcher Dienst? Socket = IP-Adresse + Port Wichtig: TCP-Port 443 und UDP-Port 443 sind technisch getrennt. Beispiel: TCP 443 = HTTPS über TCP UDP 443 = QUIC / HTTP/3 Ein Dienst kann also denselben Port bei TCP und UDP unterschiedlich verwenden. --- **Firewall-Bezug** Firewalls können sowohl TCP als auch UDP filtern. Dabei prüfen sie zum Beispiel: - Quell-IP - Ziel-IP - Quellport - Zielport - Protokoll TCP oder UDP Bei TCP kann eine Stateful Firewall den Verbindungszustand gut erkennen: SYN → SYN-ACK → ACK → Verbindung steht Bei UDP gibt es keinen echten Verbindungszustand wie bei TCP. Eine Stateful Firewall kann sich aber trotzdem kurzzeitig merken, dass ein internes Gerät ein UDP-Datagramm nach außen gesendet hat. Beispiel: Client sendet DNS-Anfrage per UDP nach außen. Firewall merkt sich diese Anfrage kurzzeitig. DNS-Antwort darf zurück. Unerwartete UDP-Pakete von außen werden blockiert. --- **TCP versus UDP als Tabelle** | Merkmal | TCP | UDP | |---|---|---| | Voller Name | Transmission Control Protocol | User Datagram Protocol | | Verbindungsaufbau | Ja, 3-Wege-Handshake | Nein | | Erste Nachricht | SYN | Direkt Datagramm/Nutzdaten | | Zuverlässigkeit | Eingebaut | Nicht eingebaut | | Reihenfolgekontrolle | Ja | Nein | | Sequenznummern | Ja | Nicht wie TCP | | ACK-Bestätigungen | Ja | Nicht durch UDP selbst | | Erneute Übertragung | Ja | Nein | | Verwaltungsaufwand | Höher | Geringer | | Latenz | Oft höher | Oft geringer | | Typische Nutzung | Zuverlässige Datenübertragung | Echtzeit oder kleine schnelle Anfragen | | Beispiele | HTTPS, SSH, E-Mail, Dateiübertragung | DNS, VoIP, Streaming, Gaming, QUIC | --- **Einfacher Vergleich** TCP ist wie ein Einschreiben: Es wird geprüft, bestätigt und bei Problemen erneut gesendet. UDP ist wie eine Postkarte: Sie wird direkt abgeschickt, aber es gibt keine eingebaute Garantie, dass sie ankommt oder in welcher Reihenfolge sie ankommt. --- **IHK-sichere Kurzformulierung** TCP ist ein verbindungsorientiertes und zuverlässiges Transportprotokoll. Vor der Datenübertragung wird über den 3-Wege-Handshake eine Verbindung aufgebaut. TCP verwendet Sequenznummern, ACK-Bestätigungen, Reihenfolgekontrolle und erneute Übertragung verlorener Daten. Dadurch eignet sich TCP für Anwendungen, bei denen Daten vollständig und korrekt ankommen müssen. UDP ist ein verbindungsloses Transportprotokoll mit geringem Verwaltungsaufwand. UDP baut vor dem Senden keine Verbindung auf und bietet keine eingebaute Garantie für Zustellung, Reihenfolge oder erneute Übertragung verlorener Daten. Dadurch eignet sich UDP besonders für Anwendungen, bei denen geringe Verzögerung wichtiger ist als vollständige Kontrolle. --- **Merksätze** TCP = erst Verbindung aufbauen, dann Nutzdaten senden UDP = keine Verbindung aufbauen, Daten direkt senden TCP = zuverlässig, geordnet und kontrolliert UDP = verbindungslos, schlank und oft latenzärmer TCP fragt vorher: "Darf ich eine Verbindung aufbauen?" UDP sendet direkt: "Hier sind die Daten." TCP nutzt SYN, SYN-ACK und ACK für den Verbindungsaufbau. UDP hat keinen 3-Wege-Handshake. TCP erkennt fehlende Daten und überträgt sie erneut. UDP macht das nicht automatisch. TCP eignet sich für vollständige Daten. UDP eignet sich für schnelle oder zeitkritische Daten. # 7.1 OSI-Schicht 4 – Transportschicht Die Transportschicht ist Schicht 4 des OSI-Modells. Sie liegt zwischen: Schicht 3: Vermittlungsschicht / Netzwerkschicht und Schicht 5: Sitzungsschicht Die Hauptaufgabe von Schicht 4 ist: Daten zwischen Anwendungen auf Endgeräten transportieren. Dabei geht es besonders um: - TCP - UDP - Ports - Verbindungen - Zuverlässigkeit - Reihenfolge - Flusskontrolle - Fehlerbehandlung - Segmentierung Merksatz: Schicht 4 = Transport zwischen Anwendungen mit TCP, UDP und Ports. --- **Grundidee von Schicht 4** Schicht 3 bringt IP-Pakete von einem Gerät zu einem anderen Gerät. Schicht 4 sorgt dafür, dass die Daten zur richtigen Anwendung auf diesem Gerät gelangen. Beispiel: Ein Server hat eine IP-Adresse. Auf dem Server laufen mehrere Dienste. Zum Beispiel: Webserver SSH Mailserver Datenbank Damit klar ist, welcher Dienst gemeint ist, nutzt Schicht 4 Ports. Merksatz: IP bringt zum Gerät. Port bringt zur Anwendung. --- **Einordnung im OSI-Modell** | OSI-Schicht | Name | Aufgabe | |---:|---|---| | 7 | Anwendungsschicht | Netzwerkdienste für Anwendungen | | 6 | Darstellungsschicht | Darstellung, Codierung, Verschlüsselung | | 5 | Sitzungsschicht | Sitzungen verwalten | | 4 | Transportschicht | Transport zwischen Anwendungen | | 3 | Vermittlungsschicht / Netzwerkschicht | IP-Adressierung und Routing | | 2 | Sicherungsschicht | Frames, MAC-Adressen, lokale Übertragung | | 1 | Bitübertragungsschicht | Bits als Signale übertragen | Merksatz: Schicht 4 sitzt über IP und unter den Anwendungsschichten. --- **Warum braucht man Schicht 4?** Schicht 3 kennt IP-Adressen. Eine IP-Adresse sagt: welches Gerät? Aber ein Gerät kann viele Dienste gleichzeitig anbieten. Beispiel Server: | Dienst | typischer Port | |---|---:| | HTTP | 80 | | HTTPS | 443 | | SSH | 22 | | DNS | 53 | | SMTP | 25 | | IMAP | 143 | | RDP | 3389 | Schicht 4 sorgt dafür, dass Daten beim richtigen Dienst landen. Merksatz: Ohne Ports wüsste ein Gerät nicht, für welchen Dienst die Daten bestimmt sind. --- **Ports** Ein Port ist eine logische Nummer auf Schicht 4. Ports werden verwendet, um Anwendungen oder Dienste auf einem Gerät zu unterscheiden. Beispiel: IP-Adresse: 192.168.10.50 Port: 443 Zusammen: 192.168.10.50:443 Das bedeutet: Dienst auf Port 443 auf dem Gerät 192.168.10.50 Merksatz: Port = logische Dienstnummer auf Schicht 4. --- **Port ist nicht gleich Switch-Port** Der Begriff Port kann verwirrend sein. | Begriff | Bedeutung | Schicht | |---|---|---:| | Switch-Port | physischer Anschluss am Switch | 1 / 2 | | TCP-Port | logische Dienstnummer | 4 | | UDP-Port | logische Dienstnummer | 4 | Beispiel: Switch-Port 5: Kabel steckt am Switch. TCP-Port 443: HTTPS-Dienst auf einem Server. Merksatz: Switch-Port = physisch. TCP-/UDP-Port = logisch. --- **TCP** TCP steht für: Transmission Control Protocol TCP ist ein verbindungsorientiertes Transportprotokoll. Das bedeutet: Vor der eigentlichen Datenübertragung wird eine Verbindung aufgebaut. TCP bietet unter anderem: - Verbindungsaufbau - zuverlässige Übertragung - Reihenfolge der Daten - Bestätigungen - erneute Übertragung bei Verlust - Flusskontrolle - Staukontrolle Merksatz: TCP = zuverlässig und verbindungsorientiert. --- **UDP** UDP steht für: User Datagram Protocol UDP ist ein verbindungsloses Transportprotokoll. Das bedeutet: Es wird keine Verbindung wie bei TCP aufgebaut. UDP sendet Datagramme ohne eingebaute Garantie für: - Zustellung - Reihenfolge - erneute Übertragung - Bestätigung UDP ist dadurch einfacher und schneller, aber weniger zuverlässig. Merksatz: UDP = schnell und verbindungslos. --- **TCP und UDP im Vergleich** | Merkmal | TCP | UDP | |---|---|---| | Verbindungsaufbau | ja | nein | | Zuverlässigkeit | hoch | keine eingebaute Garantie | | Reihenfolge | wird sichergestellt | keine eingebaute Garantie | | Bestätigung | ja | nein | | erneute Übertragung | ja | nein | | Overhead | höher | geringer | | typische Nutzung | Web, Mail, SSH | DNS, VoIP, Streaming, Gaming | Merksatz: TCP = sicherer Transport. UDP = schlanker Transport. --- **Verbindungsorientiert** Verbindungsorientiert bedeutet: Vor der Datenübertragung wird eine Verbindung aufgebaut. TCP arbeitet verbindungsorientiert. Dabei wird geprüft: Ist die Gegenstelle erreichbar? Können beide Seiten kommunizieren? Welche Anfangswerte werden verwendet? Erst danach werden Nutzdaten übertragen. Merksatz: Verbindungsorientiert = Verbindung vor Datenübertragung. --- **Verbindungslos** Verbindungslos bedeutet: Es wird keine feste Verbindung aufgebaut. UDP arbeitet verbindungslos. Ein UDP-Datagramm wird einfach gesendet. Der Sender weiß durch UDP allein nicht sicher: ob es angekommen ist ob es in richtiger Reihenfolge angekommen ist ob es mehrfach angekommen ist Wenn eine Anwendung Zuverlässigkeit braucht, muss sie das selbst lösen. Merksatz: Verbindungslos = senden ohne vorherigen Verbindungsaufbau. --- **TCP-Handshake** TCP baut eine Verbindung mit dem sogenannten Drei-Wege-Handshake auf. Die drei Schritte sind: 1. SYN 2. SYN-ACK 3. ACK Vereinfacht: Client: Ich möchte eine Verbindung aufbauen. Server: Einverstanden, ich bestätige. Client: Bestätigung erhalten. Danach beginnt die eigentliche Datenübertragung. Merksatz: TCP-Verbindung startet mit SYN, SYN-ACK, ACK. --- **Drei-Wege-Handshake** | Schritt | Richtung | Bedeutung | |---:|---|---| | 1 | Client → Server | SYN | | 2 | Server → Client | SYN-ACK | | 3 | Client → Server | ACK | SYN bedeutet: Synchronize ACK bedeutet: Acknowledgement Nach dem dritten Schritt gilt die TCP-Verbindung als aufgebaut. Merksatz: Drei-Wege-Handshake = SYN, SYN-ACK, ACK. --- **TCP-Bestätigungen** TCP arbeitet mit Bestätigungen. Wenn Daten ankommen, bestätigt der Empfänger den Empfang. Wenn Daten verloren gehen, können sie erneut übertragen werden. Dadurch erreicht TCP eine zuverlässige Datenübertragung. Beispiel: Sender sendet Daten. Empfänger bestätigt Empfang. Sender weiß: Daten sind angekommen. Merksatz: TCP nutzt ACKs zur Bestätigung. --- **Reihenfolge bei TCP** TCP sorgt dafür, dass Daten in der richtigen Reihenfolge an die Anwendung übergeben werden. Wenn Datenpakete unterwegs vertauscht ankommen, kann TCP sie wieder sortieren. Beispiel: gesendet: Teil 1, Teil 2, Teil 3 angekommen: Teil 1, Teil 3, Teil 2 TCP kann die Reihenfolge für die Anwendung wieder herstellen. Merksatz: TCP stellt die Reihenfolge der Daten sicher. --- **Sequenznummern** TCP nutzt Sequenznummern. Sie helfen dabei: - Daten in Reihenfolge zu bringen - fehlende Daten zu erkennen - Daten korrekt zu bestätigen Wichtig: Sequenznummern sind keine Ports. Ports zeigen den Dienst. Sequenznummern zeigen die Position von Daten im TCP-Datenstrom. Merksatz: Port = Dienst. Sequenznummer = Position im TCP-Datenstrom. --- **TCP-Segment** Die Datenform bei TCP auf Schicht 4 heißt: Segment Ein TCP-Segment enthält unter anderem: - Quell-Port - Ziel-Port - Sequenznummer - Bestätigungsnummer - Steuerbits - Nutzdaten Merksatz: TCP arbeitet mit Segmenten. --- **UDP-Datagramm** Die Datenform bei UDP auf Schicht 4 heißt: Datagramm Ein UDP-Datagramm enthält unter anderem: - Quell-Port - Ziel-Port - Länge - Prüfsumme - Nutzdaten UDP ist einfacher aufgebaut als TCP. Merksatz: UDP arbeitet mit Datagrammen. --- **Segment und Datagramm unterscheiden** | Protokoll | Datenform auf Schicht 4 | |---|---| | TCP | Segment | | UDP | Datagramm | Wichtig: In der Praxis wird oft allgemein von Paketen gesprochen. Fachlich genauer sollte man unterscheiden. Merksatz: TCP = Segment. UDP = Datagramm. --- **Portnummern** Portnummern liegen im Bereich: 0 bis 65535 Warum? Ports sind 16 Bit groß. 16 Bit ermöglichen: 65536 verschiedene Werte Von: 0 bis: 65535 Merksatz: Portnummern gehen von 0 bis 65535. --- **Well-Known Ports** Well-Known Ports sind bekannte, standardisierte Ports. Sie liegen im Bereich: 0 bis 1023 Beispiele: | Dienst | Protokoll | Port | |---|---|---:| | FTP | TCP | 21 | | SSH | TCP | 22 | | SMTP | TCP | 25 | | DNS | TCP / UDP | 53 | | HTTP | TCP | 80 | | HTTPS | TCP | 443 | Merksatz: Well-Known Ports = 0 bis 1023. --- **Registered Ports** Registered Ports liegen im Bereich: 1024 bis 49151 Sie werden häufig von Anwendungen, Herstellern oder Diensten genutzt. Beispiele können je nach Anwendung unterschiedlich sein. Für die Prüfung ist meistens wichtiger: Well-Known Ports kennen und Portbereiche grob einordnen. Merksatz: Registered Ports = 1024 bis 49151. --- **Dynamic oder Ephemeral Ports** Dynamic Ports werden auch genannt: Ephemeral Ports Sie liegen im Bereich: 49152 bis 65535 Clients nutzen solche Ports oft als temporäre Quell-Ports. Beispiel: Client öffnet Webseite. Quell-Port: 52344 Ziel-Port: 443 Der Quell-Port wird temporär für diese Verbindung genutzt. Merksatz: Ephemeral Port = temporärer Client-Port. --- **Quell-Port und Ziel-Port** Ein TCP- oder UDP-Paket enthält: - Quell-Port - Ziel-Port Beispiel HTTPS-Aufruf: Client: 192.168.10.20:52344 Server: 93.184.216.34:443 Der Ziel-Port 443 zeigt: Der Client möchte HTTPS erreichen. Der Quell-Port 52344 hilft dem Client, die Antwort der richtigen Verbindung zuzuordnen. Merksatz: Ziel-Port = gewünschter Dienst. Quell-Port = Rückzuordnung beim Absender. --- **Socket** Ein Socket beschreibt eine Kombination aus: IP-Adresse und Port Beispiel: 192.168.10.20:52344 Oder: 93.184.216.34:443 Bei TCP-Verbindungen betrachtet man oft die Kombination aus: Quell-IP Quell-Port Ziel-IP Ziel-Port Protokoll Diese Kombination macht eine Verbindung eindeutig. Merksatz: Socket = IP-Adresse plus Port. --- **Typische Dienste und Ports** | Dienst | Protokoll | Port | |---|---|---:| | FTP Steuerverbindung | TCP | 21 | | SSH | TCP | 22 | | Telnet | TCP | 23 | | SMTP | TCP | 25 | | DNS | TCP / UDP | 53 | | DHCP Server | UDP | 67 | | DHCP Client | UDP | 68 | | HTTP | TCP | 80 | | POP3 | TCP | 110 | | IMAP | TCP | 143 | | HTTPS | TCP | 443 | | RDP | TCP | 3389 | Merksatz: Die wichtigsten Standardports sollte man sicher kennen. --- **DNS und TCP/UDP** DNS nutzt häufig UDP Port 53. Warum? Normale DNS-Anfragen sind meist klein und schnell. DNS kann aber auch TCP Port 53 verwenden. Zum Beispiel: - Zonentransfers - große Antworten - bestimmte DNS-Sicherheits- oder Sonderfälle Prüfungsfalle: DNS ist nicht nur UDP, sondern kann TCP und UDP 53 nutzen. Merksatz: DNS = UDP 53 häufig, TCP 53 ebenfalls möglich. --- **DHCP und UDP** DHCP nutzt UDP. Wichtige Ports: | Richtung | Port | |---|---:| | DHCP Server | UDP 67 | | DHCP Client | UDP 68 | DHCP wird genutzt, um IP-Konfiguration automatisch zu vergeben. Merksatz: DHCP nutzt UDP 67 und 68. --- **HTTP und HTTPS** HTTP nutzt typischerweise: TCP 80 HTTPS nutzt typischerweise: TCP 443 HTTPS ist HTTP über TLS-Verschlüsselung. Wichtig: HTTPS ist nicht einfach nur ein anderer Port, sondern nutzt Verschlüsselung über TLS. Merksatz: HTTP = TCP 80. HTTPS = TCP 443. --- **SSH und Telnet** SSH nutzt typischerweise: TCP 22 Telnet nutzt typischerweise: TCP 23 Wichtiger Unterschied: SSH ist verschlüsselt. Telnet ist unverschlüsselt. In modernen Netzen sollte SSH verwendet werden, nicht Telnet. Merksatz: SSH sicherer als Telnet. --- **Transport und Anwendung** Schicht 4 transportiert Daten zwischen Anwendungen. Die Anwendung selbst liegt höher. Beispiel: HTTPS nutzt TCP 443. Dabei ist: TCP = Schicht 4 HTTPS = Anwendungsschicht mit TLS-Bezug Merksatz: Port gehört zu Schicht 4. Dienst gehört zu höheren Schichten. --- **TCP und Firewall** Firewalls nutzen häufig Schicht-4-Informationen. Beispiel-Regel: Erlaube TCP 443 von Client-Netz zum Internet. Das bedeutet: HTTPS-Verbindungen nach außen sind erlaubt. Andere Ports können blockiert werden. Merksatz: Firewall-Regeln nutzen oft IP-Adressen und Ports. --- **UDP und Firewall** Auch UDP kann durch Firewalls erlaubt oder blockiert werden. Beispiele: DNS über UDP 53 DHCP über UDP 67/68 VoIP über UDP VPN über UDP NTP über UDP 123 Da UDP verbindungslos ist, muss eine Firewall den Verkehr anders verfolgen als bei TCP. Merksatz: UDP braucht passende Firewall-Regeln, auch ohne TCP-Verbindung. --- **TCP-Verbindungszustände** TCP kennt verschiedene Verbindungszustände. Beispiele: LISTEN SYN-SENT ESTABLISHED FIN-WAIT TIME-WAIT CLOSED Für AP1/AP2 ist besonders wichtig: LISTEN bedeutet: Dienst wartet auf eingehende Verbindungen. ESTABLISHED bedeutet: Verbindung besteht. Merksatz: LISTEN = Dienst wartet. ESTABLISHED = Verbindung steht. --- **Port offen oder geschlossen** Ein Port kann aus Sicht eines Clients unterschiedlich wirken. | Zustand | Bedeutung | |---|---| | offen | Dienst nimmt Verbindungen an | | geschlossen | kein Dienst hört auf diesem Port | | gefiltert | Firewall blockiert oder verwirft | Wichtig: Ein offener Port bedeutet, dass ein Dienst erreichbar ist. Ein geschlossener Port bedeutet nicht zwingend, dass das Gerät offline ist. Merksatz: Portstatus sagt etwas über den Dienst, nicht nur über das Gerät. --- **Typische Schicht-4-Fehler** Typische Fehler auf Schicht 4 sind: - falscher Port - Dienst hört nicht auf erwartetem Port - Firewall blockiert TCP oder UDP - TCP-Verbindung wird nicht aufgebaut - UDP-Antwort kommt nicht zurück - Portweiterleitung auf falschen Port - NAT/PAT-Portzuordnung falsch - Anwendung nutzt anderes Protokoll als erwartet - TCP-Handshake scheitert Merksatz: Schicht-4-Fehler betreffen TCP, UDP und Ports. --- **Schicht 3 oder Schicht 4 unterscheiden** | Frage | eher Schicht | |---|---:| | Ist die IP-Adresse erreichbar? | 3 | | Funktioniert Ping auf IP? | 3 | | Gibt es eine Route? | 3 | | Ist TCP-Port 443 erreichbar? | 4 | | Ist UDP-Port 53 erreichbar? | 4 | | Baut TCP eine Verbindung auf? | 4 | | Antwortet der Webdienst korrekt? | 7 | Merksatz: IP erreichbar = Schicht 3. Port erreichbar = Schicht 4. --- **Beispiel: Ping geht, Webseite geht nicht** Fehlerbild: ping server funktioniert. Webseite funktioniert nicht. Dann ist Schicht 3 wahrscheinlich grundsätzlich erreichbar. Mögliche Ursachen: - TCP-Port 80 oder 443 blockiert - Webserver läuft nicht - Dienst hört auf anderer IP - Dienst hört auf anderem Port - Firewall blockiert - Reverse Proxy falsch - TLS-Problem Merksatz: Ping geht, Dienst nicht: Schicht 4 und 7 prüfen. --- **Beispiel: Port 443 blockiert** Ein Client möchte HTTPS nutzen. Ziel: server.example.local:443 Mögliche Fehler: - Server ist erreichbar, aber TCP 443 ist geschlossen - Firewall blockiert TCP 443 - Dienst läuft nur auf TCP 8443 - Portweiterleitung zeigt auf falschen Port Merksatz: HTTPS braucht erreichbaren TCP-Port 443. --- **Beispiel: DNS funktioniert nicht** DNS nutzt häufig UDP 53 und teilweise TCP 53. Wenn DNS nicht funktioniert, prüft man: - DNS-Server-IP korrekt? - DNS-Server erreichbar? - UDP 53 erlaubt? - TCP 53 erlaubt? - Firewall blockiert? - DNS-Dienst läuft? - Antwort kommt zurück? Merksatz: DNS-Probleme können Schicht 3, 4 oder 7 betreffen. --- **Beispiel: UDP-Dienst antwortet nicht** Bei UDP gibt es keinen TCP-Handshake. Wenn ein UDP-Dienst nicht antwortet, kann das viele Ursachen haben: - Dienst läuft nicht - Firewall blockiert - Antwortweg fehlt - NAT/PAT-Problem - Anwendung antwortet nur auf gültige Anfragen - Paketverlust - falscher Port Merksatz: UDP-Fehler sind oft schwerer eindeutig zu erkennen als TCP-Fehler. --- **Einordnung in das OSI-Modell** | Thema | Schicht | |---|---:| | IP-Adresse | 3 | | Routing | 3 | | ICMP | 3 | | TCP | 4 | | UDP | 4 | | Port | 4 | | Socket | 4 mit IP-Bezug | | TCP-Handshake | 4 | | DNS-Protokoll | 7, nutzt TCP/UDP 53 | | HTTP | 7, nutzt TCP 80 | | HTTPS | 7, nutzt TCP 443 und TLS | | DHCP | 7, nutzt UDP 67/68 | Merksatz: TCP, UDP und Ports = Schicht 4. --- **Was Schicht 4 nicht macht** Schicht 4 macht nicht: - IP-Routing zwischen Netzen - MAC-Adressen im LAN auflösen - DNS-Namen in IP-Adressen auflösen - Webseiten darstellen - Benutzer authentifizieren - Zertifikate prüfen - Inhalte interpretieren - Dateien speichern Diese Aufgaben liegen auf anderen Schichten. Merksatz: Schicht 4 transportiert, interpretiert aber keine Anwendung. --- **Typische IHK-Fragen** In AP1 und AP2 kann zum Beispiel gefragt werden: - Welche Aufgabe hat die Transportschicht? - Was ist ein Port? - Was ist der Unterschied zwischen Switch-Port und TCP-Port? - Was ist TCP? - Was ist UDP? - Was ist der Unterschied zwischen TCP und UDP? - Was bedeutet verbindungsorientiert? - Was bedeutet verbindungslos? - Wie funktioniert der TCP-Handshake? - Welche Ports haben HTTP, HTTPS, SSH, DNS und DHCP? - Warum nutzt DNS TCP und UDP? - Was bedeutet Socket? - Was ist ein Ephemeral Port? - Warum kann Ping funktionieren, aber HTTPS nicht? - Warum nutzt ICMP keine Ports? --- **Typische Prüfungsfallen** TCP gehört zu Schicht 4. UDP gehört zu Schicht 4. Ports gehören zu Schicht 4. ICMP nutzt keine TCP- oder UDP-Ports. Switch-Port ist nicht TCP-Port. TCP ist verbindungsorientiert. UDP ist verbindungslos. TCP ist zuverlässiger als UDP. UDP ist schlanker als TCP. TCP-Handshake = SYN, SYN-ACK, ACK. HTTP nutzt TCP 80. HTTPS nutzt TCP 443. SSH nutzt TCP 22. DNS nutzt UDP 53 und auch TCP 53. DHCP nutzt UDP 67 und 68. Ping funktioniert heißt nicht, dass ein TCP-Port offen ist. Port offen heißt nicht automatisch, dass die Anwendung korrekt funktioniert. --- **Wichtige Begriffe kurz erklärt** | Begriff | Kurze Erklärung | |---|---| | Transportschicht | OSI-Schicht 4 | | TCP | verbindungsorientiertes Transportprotokoll | | UDP | verbindungsloses Transportprotokoll | | Port | logische Dienstnummer | | TCP-Port | Port für TCP-Dienst | | UDP-Port | Port für UDP-Dienst | | Socket | IP-Adresse plus Port | | Segment | TCP-Datenform auf Schicht 4 | | Datagramm | UDP-Datenform auf Schicht 4 | | SYN | TCP-Verbindungsaufbau-Anfrage | | ACK | Bestätigung bei TCP | | Drei-Wege-Handshake | SYN, SYN-ACK, ACK | | Sequenznummer | Position im TCP-Datenstrom | | Well-Known Port | Port 0 bis 1023 | | Registered Port | Port 1024 bis 49151 | | Ephemeral Port | temporärer Client-Port | | LISTEN | Dienst wartet auf Verbindung | | ESTABLISHED | TCP-Verbindung besteht | --- **IHK-sichere Kurzformulierung** Die Transportschicht ist Schicht 4 des OSI-Modells. Sie ist für den Transport von Daten zwischen Anwendungen auf Endgeräten zuständig. Dafür werden vor allem TCP, UDP und Ports verwendet. TCP ist verbindungsorientiert und bietet zuverlässige Übertragung mit Verbindungsaufbau, Bestätigungen, Reihenfolge und erneuter Übertragung. UDP ist verbindungslos, schlanker und bietet keine eingebaute Garantie für Zustellung oder Reihenfolge. Ports dienen dazu, Dienste auf einem Gerät zu unterscheiden. Ein Socket besteht aus IP-Adresse und Port. Der TCP-Verbindungsaufbau erfolgt über den Drei-Wege-Handshake mit SYN, SYN-ACK und ACK. --- **Merksätze** Schicht 4 = Transportschicht. Schicht 4 = TCP, UDP und Ports. IP bringt zum Gerät. Port bringt zur Anwendung. Port = logische Dienstnummer. Switch-Port ist physisch. TCP-Port ist logisch. TCP = verbindungsorientiert. UDP = verbindungslos. TCP = zuverlässig. UDP = schlank und schnell. TCP-Handshake = SYN, SYN-ACK, ACK. TCP nutzt Segmente. UDP nutzt Datagramme. Portnummern gehen von 0 bis 65535. Well-Known Ports = 0 bis 1023. Ephemeral Ports = temporäre Client-Ports. HTTP = TCP 80. HTTPS = TCP 443. SSH = TCP 22. DNS = UDP 53 und TCP 53. DHCP = UDP 67 und 68. ICMP nutzt keine Ports. Ping prüft nicht, ob ein TCP-Port offen ist. IP erreichbar = Schicht 3. Port erreichbar = Schicht 4. Anwendung korrekt = höhere Schicht. # 7.2 TCP und UDP im Detail TCP und UDP sind die wichtigsten Transportprotokolle auf OSI-Schicht 4. Beide haben dieselbe Grundaufgabe: Daten zwischen Anwendungen auf Endgeräten transportieren. Der große Unterschied liegt darin, wie sie das machen. TCP arbeitet: verbindungsorientiert zuverlässig mit Bestätigungen UDP arbeitet: verbindungslos schlanker ohne eingebaute Zustellgarantie Merksatz: TCP = zuverlässig. UDP = schnell und einfach. --- **Warum gibt es TCP und UDP?** Nicht jede Anwendung hat dieselben Anforderungen. Manche Anwendungen brauchen sichere und vollständige Datenübertragung. Beispiele: - Webseite laden - Datei übertragen - E-Mail senden - SSH-Verbindung - Datenbankzugriff Andere Anwendungen brauchen vor allem geringe Verzögerung. Beispiele: - VoIP - Livestreaming - Online-Gaming - DNS-Anfragen - Video-Konferenzen Deshalb gibt es unterschiedliche Transportprotokolle. Merksatz: Unterschiedliche Anwendungen brauchen unterschiedliche Transportarten. --- **TCP-Grundidee** TCP steht für: Transmission Control Protocol TCP stellt eine Verbindung zwischen zwei Anwendungen her. Dabei sorgt TCP dafür, dass Daten: - vollständig ankommen - in der richtigen Reihenfolge ankommen - bestätigt werden - bei Verlust erneut gesendet werden - kontrolliert übertragen werden Merksatz: TCP kümmert sich um zuverlässige Datenübertragung. --- **UDP-Grundidee** UDP steht für: User Datagram Protocol UDP sendet einzelne Datagramme ohne vorherigen Verbindungsaufbau. UDP kümmert sich nicht selbst darum, ob Daten: - angekommen sind - vollständig angekommen sind - in richtiger Reihenfolge angekommen sind - erneut gesendet werden müssen Dafür ist UDP sehr schlank. Merksatz: UDP sendet einfach, ohne Verbindung aufzubauen. --- **TCP und UDP direkt vergleichen** | Merkmal | TCP | UDP | |---|---|---| | Verbindungsaufbau | ja | nein | | Verbindung | verbindungsorientiert | verbindungslos | | Zustellgarantie | ja, durch Mechanismen | nein | | Reihenfolge | wird sichergestellt | nicht sichergestellt | | Bestätigungen | ja | nein | | erneute Übertragung | ja | nein | | Geschwindigkeit | mehr Overhead | weniger Overhead | | Datenform | Segment | Datagramm | | typische Nutzung | HTTP, HTTPS, SSH, Mail | DNS, DHCP, VoIP, Streaming | Merksatz: TCP kontrolliert mehr. UDP ist einfacher. --- **Verbindungsorientiert bei TCP** Verbindungsorientiert bedeutet: Vor der eigentlichen Datenübertragung wird eine Verbindung aufgebaut. TCP prüft dabei, ob beide Seiten bereit sind. Der Verbindungsaufbau erfolgt durch den Drei-Wege-Handshake: SYN SYN-ACK ACK Erst danach werden Nutzdaten übertragen. Merksatz: TCP baut vor der Datenübertragung eine Verbindung auf. --- **Verbindungslos bei UDP** Verbindungslos bedeutet: Es gibt keinen Verbindungsaufbau wie bei TCP. UDP sendet ein Datagramm direkt an Ziel-IP und Ziel-Port. Der Sender erhält durch UDP selbst keine sichere Information darüber: ob das Datagramm angekommen ist ob es verworfen wurde ob mehrere Datagramme in richtiger Reihenfolge ankamen Merksatz: UDP hat keinen Drei-Wege-Handshake. --- **TCP-Drei-Wege-Handshake** Der TCP-Verbindungsaufbau besteht aus drei Schritten. | Schritt | Richtung | Bedeutung | |---:|---|---| | 1 | Client → Server | SYN | | 2 | Server → Client | SYN-ACK | | 3 | Client → Server | ACK | Vereinfacht: Client fragt an. Server bestätigt und fragt zurück. Client bestätigt. Danach ist die Verbindung aufgebaut. Merksatz: TCP-Handshake = SYN, SYN-ACK, ACK. --- **SYN** SYN steht für: Synchronize Ein SYN wird beim TCP-Verbindungsaufbau gesendet. Der Client sagt damit vereinfacht: Ich möchte eine TCP-Verbindung aufbauen. Das SYN enthält unter anderem Startinformationen für die TCP-Kommunikation. Merksatz: SYN startet den TCP-Verbindungsaufbau. --- **SYN-ACK** SYN-ACK ist die Antwort des Servers auf das SYN des Clients. Der Server sagt damit vereinfacht: Ich habe deine Anfrage erhalten und bin bereit für die Verbindung. SYN-ACK enthält: SYN des Servers ACK als Bestätigung des Client-SYN Merksatz: SYN-ACK bestätigt die Anfrage und synchronisiert zurück. --- **ACK** ACK steht für: Acknowledgement ACK bedeutet: Bestätigung Im dritten Schritt bestätigt der Client das SYN-ACK des Servers. Danach gilt die TCP-Verbindung als aufgebaut. Merksatz: ACK bestätigt empfangene TCP-Informationen. --- **TCP-Datenübertragung nach dem Handshake** Nach dem Drei-Wege-Handshake können Nutzdaten übertragen werden. TCP nutzt dafür: - Sequenznummern - Bestätigungsnummern - Prüfsummen - Fenstergröße - erneute Übertragung bei Verlust Dadurch wird die Übertragung zuverlässiger. Merksatz: Nach dem Handshake sorgt TCP für geordnete Datenübertragung. --- **Sequenznummern** TCP nutzt Sequenznummern, um Daten zu ordnen. Sie helfen dabei: - Reihenfolge wiederherzustellen - fehlende Daten zu erkennen - Daten korrekt zu bestätigen Beispiel: Teil 1 kommt an. Teil 3 kommt an. Teil 2 fehlt. TCP erkennt: Es fehlt etwas. Dann kann die fehlende Information erneut übertragen werden. Merksatz: Sequenznummern helfen TCP, Daten richtig zu sortieren. --- **Bestätigungsnummern** Bestätigungsnummern zeigen dem Sender, welche Daten angekommen sind. Der Empfänger bestätigt nicht nur: Ich habe etwas bekommen. Sondern sinngemäß: Ich habe alles bis zu dieser Stelle bekommen und erwarte als Nächstes diese Nummer. Merksatz: TCP bestätigt empfangene Daten mit ACKs. --- **Erneute Übertragung bei TCP** Wenn TCP erkennt, dass Daten fehlen, können sie erneut übertragen werden. Mögliche Gründe für erneute Übertragung: - Paketverlust - beschädigte Daten - keine Bestätigung erhalten - Timeout - Überlastung im Netz Dadurch ist TCP zuverlässiger als UDP. Merksatz: TCP kann verlorene Daten erneut senden. --- **Reihenfolge bei TCP** IP-Pakete können im Netzwerk unterschiedliche Wege nehmen. Dadurch können Daten in anderer Reihenfolge ankommen. TCP kann sie wieder richtig zusammensetzen. Beispiel: Gesendet: 1, 2, 3, 4 Angekommen: 1, 3, 2, 4 TCP übergibt der Anwendung die Daten wieder in korrekter Reihenfolge. Merksatz: TCP sorgt für richtige Reihenfolge. --- **Flusskontrolle** Flusskontrolle bedeutet: Der Sender soll den Empfänger nicht überfordern. TCP nutzt dafür unter anderem die Fenstergröße. Die Fenstergröße gibt an, wie viele Daten gesendet werden dürfen, bevor weitere Bestätigungen nötig sind. Vereinfacht: Empfänger sagt: So viel kann ich gerade aufnehmen. Merksatz: Flusskontrolle schützt den Empfänger vor Überlastung. --- **Staukontrolle** Staukontrolle bedeutet: TCP versucht, Überlastung im Netzwerk zu vermeiden. Wenn Paketverlust oder Verzögerung auftritt, kann TCP die Sendeleistung anpassen. Ziel: Das Netzwerk soll nicht weiter überlastet werden. Merksatz: Staukontrolle schützt das Netzwerk vor Überlastung. --- **TCP-Verbindungsabbau** TCP-Verbindungen werden geordnet beendet. Dabei kommen häufig FIN- und ACK-Nachrichten vor. Vereinfacht: Eine Seite sagt: Ich möchte die Verbindung beenden. Die andere Seite bestätigt. Es gibt auch RST. RST bedeutet: Verbindung sofort abbrechen. Merksatz: FIN beendet geordnet. RST bricht ab. --- **TCP-Zustände** TCP kennt verschiedene Zustände. Wichtige Beispiele: | Zustand | Bedeutung | |---|---| | LISTEN | Dienst wartet auf eingehende Verbindung | | SYN-SENT | Client hat SYN gesendet | | SYN-RECEIVED | Server hat SYN erhalten und SYN-ACK gesendet | | ESTABLISHED | Verbindung besteht | | FIN-WAIT | Verbindung wird beendet | | TIME-WAIT | Wartephase nach Verbindungsende | | CLOSED | Verbindung geschlossen | Merksatz: ESTABLISHED bedeutet: TCP-Verbindung steht. --- **UDP-Datagramm** UDP nutzt Datagramme. Ein UDP-Datagramm enthält unter anderem: - Quell-Port - Ziel-Port - Länge - Prüfsumme - Nutzdaten UDP hat deutlich weniger Steuerinformationen als TCP. Merksatz: UDP-Datagramm = einfache Transport-Dateneinheit. --- **Warum UDP trotz fehlender Garantie sinnvoll ist** UDP ist sinnvoll, wenn Geschwindigkeit oder geringe Verzögerung wichtiger ist als perfekte Vollständigkeit. Beispiel VoIP: Wenn ein kleines Audiopaket verloren geht, ist es oft besser, einfach weiterzumachen. Eine spätere erneute Übertragung wäre zu spät und würde nur stören. Merksatz: Bei Echtzeitdiensten ist spät manchmal schlimmer als verloren. --- **UDP bei DNS** DNS nutzt häufig UDP Port 53. Warum? DNS-Anfragen sind oft kurz. DNS-Antworten sind oft klein. Es soll schnell gehen. DNS kann aber auch TCP Port 53 verwenden. Beispiele: - große Antworten - Zonentransfers - bestimmte DNSSEC-Fälle Merksatz: DNS nutzt häufig UDP 53, kann aber auch TCP 53 nutzen. --- **UDP bei DHCP** DHCP nutzt UDP. Wichtige Ports: | Richtung | Port | |---|---:| | DHCP-Server | UDP 67 | | DHCP-Client | UDP 68 | Warum UDP? Ein Client hat am Anfang oft noch keine vollständige IP-Konfiguration. DHCP muss früh im Netzwerkprozess funktionieren. Merksatz: DHCP nutzt UDP 67 und 68. --- **UDP bei VoIP und Streaming** VoIP, Videokonferenzen und Streaming nutzen häufig UDP. Grund: geringe Verzögerung ist wichtig. Wenn ein Paket verloren geht, ist eine spätere Wiederholung oft nicht sinnvoll. Beispiel: Ein verlorener Tonfetzen bei Telefonie ist kurz störend. Eine verspätete Wiederholung würde das Gespräch stärker stören. Merksatz: Echtzeitkommunikation nutzt häufig UDP. --- **TCP bei Web und Dateiübertragung** Webseiten, Dateiübertragungen und viele Verwaltungsdienste nutzen TCP. Beispiele: - HTTP - HTTPS - SSH - FTP - SMTP - IMAP - POP3 Warum? Daten sollen vollständig und korrekt ankommen. Bei einer Datei wäre es schlecht, wenn Teile fehlen oder vertauscht sind. Merksatz: Wenn Vollständigkeit wichtig ist, ist TCP häufig geeignet. --- **TCP und HTTPS** HTTPS nutzt typischerweise TCP Port 443. Dabei kommen mehrere Dinge zusammen: IP-Adresse für das Zielgerät TCP-Port 443 für den Dienst TCP-Verbindung für Transport TLS für Verschlüsselung HTTP für die Webanwendung Merksatz: HTTPS nutzt TCP, ist aber selbst eine höhere Anwendung mit TLS. --- **UDP und QUIC** QUIC ist ein modernes Transportprotokoll, das auf UDP basiert. HTTP/3 nutzt QUIC. Warum UDP als Grundlage? QUIC bringt eigene Mechanismen für Verbindungen, Sicherheit und Zuverlässigkeit mit, nutzt aber UDP als Transportbasis. Für AP1/AP2 reicht meistens: HTTP/3 nutzt QUIC über UDP. Merksatz: UDP bedeutet nicht automatisch, dass keine Zuverlässigkeit möglich ist; sie kann in höheren Protokollen umgesetzt werden. --- **TCP-Overhead** TCP hat mehr Overhead als UDP. Warum? - Verbindungsaufbau - Bestätigungen - Sequenznummern - erneute Übertragung - Flusskontrolle - Staukontrolle - Verbindungsabbau Dieser Overhead lohnt sich, wenn zuverlässige Übertragung wichtig ist. Merksatz: TCP hat mehr Kontrolle, aber auch mehr Aufwand. --- **UDP-Overhead** UDP hat wenig Overhead. Warum? - kein Handshake - keine TCP-Bestätigungen - keine TCP-Sequenzsteuerung - kein TCP-Verbindungszustand Das macht UDP schlank und schnell. Aber: Die Anwendung muss selbst entscheiden, ob sie zusätzliche Zuverlässigkeit braucht. Merksatz: UDP ist schlank, aber einfacher. --- **Ports bei TCP und UDP** TCP und UDP haben jeweils eigene Portbereiche. Das bedeutet: TCP 53 und UDP 53 sind nicht derselbe Kommunikationskanal. Beispiel DNS: UDP 53 für typische Abfragen TCP 53 für bestimmte Fälle Eine Firewall-Regel für TCP 53 erlaubt nicht automatisch UDP 53. Merksatz: TCP-Port und UDP-Port sind getrennt zu betrachten. --- **Gleiche Portnummer, anderes Protokoll** Die gleiche Portnummer kann bei TCP und UDP unterschiedliche Bedeutung haben. Beispiel: TCP 53 UDP 53 Beide gehören zu DNS, aber technisch sind es verschiedene Transportprotokolle. Beispiel: TCP 443 UDP 443 TCP 443 ist klassisches HTTPS. UDP 443 kann bei QUIC / HTTP/3 relevant sein. Merksatz: Portnummer immer zusammen mit TCP oder UDP betrachten. --- **Quell-Port und Ziel-Port bei TCP** Beispiel HTTPS: Client: 192.168.10.20:52344 Server: 93.184.216.34:443 Dabei ist: 52344 = temporärer Quell-Port des Clients 443 = Ziel-Port des HTTPS-Dienstes Die Antwort kommt zurück an: 192.168.10.20:52344 Merksatz: Ziel-Port zeigt den Dienst. Quell-Port hilft beim Rückweg zur Verbindung. --- **Quell-Port und Ziel-Port bei UDP** Auch UDP nutzt Quell-Port und Ziel-Port. Beispiel DNS: Client: 192.168.10.20:54001 DNS-Server: 192.168.10.1:53 Der Client sendet von einem temporären Port an UDP 53. Die Antwort kommt zurück an den temporären Client-Port. Merksatz: Auch UDP nutzt Ports für Dienst und Rückzuordnung. --- **Ephemeral Ports** Ephemeral Ports sind temporäre Client-Ports. Sie werden für ausgehende Verbindungen genutzt. Typischer Bereich: 49152 bis 65535 Beispiel: Client nutzt 53210 als Quell-Port für Verbindung zu Server TCP 443. Nach Ende der Verbindung kann der Port später wiederverwendet werden. Merksatz: Ephemeral Port = temporärer Quell-Port eines Clients. --- **Well-Known Ports** Well-Known Ports liegen im Bereich: 0 bis 1023 Sie sind bekannten Standarddiensten zugeordnet. Beispiele: | Dienst | Protokoll | Port | |---|---|---:| | FTP | TCP | 21 | | SSH | TCP | 22 | | Telnet | TCP | 23 | | SMTP | TCP | 25 | | DNS | TCP / UDP | 53 | | HTTP | TCP | 80 | | HTTPS | TCP | 443 | Merksatz: Well-Known Ports sollte man für die Prüfung sicher kennen. --- **TCP-Fehlersuche** Typische TCP-Fragen: Ist der Zielhost erreichbar? Ist der Ziel-Port offen? Lauscht der Dienst auf dem Port? Kommt ein SYN beim Server an? Antwortet der Server mit SYN-ACK? Blockiert eine Firewall? Wird die Verbindung zurückgesetzt? Gibt es NAT- oder Portweiterleitungsfehler? Merksatz: Bei TCP prüft man besonders den Verbindungsaufbau. --- **UDP-Fehlersuche** UDP-Fehlersuche ist oft schwieriger. Warum? Es gibt keinen Handshake. Wenn keine Antwort kommt, ist nicht sofort klar: Paket verloren? Dienst nicht erreichbar? Firewall blockiert? Anfrage ungültig? Antwortweg gestört? NAT-Problem? Deshalb braucht man oft Logs, Mitschnitte oder passende Testwerkzeuge. Merksatz: UDP-Fehler sind schwerer eindeutig zu erkennen als TCP-Fehler. --- **TCP-Handshake scheitert** Wenn ein TCP-Handshake scheitert, kann die Verbindung nicht aufgebaut werden. Mögliche Ursachen: - Server nicht erreichbar - Dienst hört nicht auf dem Port - Firewall blockiert SYN - Firewall blockiert SYN-ACK - NAT oder Portweiterleitung falsch - Server lehnt Verbindung ab - Rückroute fehlt Merksatz: Kein TCP-Handshake = keine TCP-Verbindung. --- **TCP Reset** Ein TCP Reset wird mit RST gekennzeichnet. RST bedeutet: Verbindung sofort abbrechen. Mögliche Ursachen: - Port geschlossen - Dienst lehnt Verbindung ab - Anwendung beendet Verbindung - Firewall sendet Reset - fehlerhafte Verbindung Merksatz: RST = TCP-Verbindung wird sofort zurückgesetzt. --- **TCP Timeout** Ein Timeout bedeutet: Eine erwartete Antwort kommt nicht rechtzeitig. Mögliche Ursachen: - Paket geht verloren - Firewall verwirft still - Server antwortet nicht - Rückweg fehlt - Routing-Problem - NAT-Problem Merksatz: Timeout bedeutet: keine rechtzeitige Antwort. --- **Gefilterter Port** Ein Port wirkt gefiltert, wenn eine Firewall Pakete blockiert oder verwirft. Unterschied: geschlossen: Ziel antwortet aktiv, dass kein Dienst vorhanden ist. gefiltert: keine oder keine klare Antwort. Merksatz: Gefiltert bedeutet oft: Firewall im Weg. --- **Offener Port** Ein Port ist offen, wenn ein Dienst auf diesem Port Verbindungen annimmt oder Anfragen beantwortet. Beispiel: TCP 443 offen bedeutet: Ein Dienst akzeptiert HTTPS-Verbindungen oder zumindest TCP-Verbindungen auf Port 443. Aber: Das sagt noch nicht, dass die Webanwendung korrekt funktioniert. Merksatz: Offener Port bedeutet: Dienst ist grundsätzlich erreichbar. --- **Geschlossener Port** Ein Port ist geschlossen, wenn kein Dienst auf diesem Port lauscht. Beispiel: Server erreichbar, aber TCP 22 geschlossen Das bedeutet: Der Server antwortet, aber SSH läuft dort nicht oder nicht auf Port 22. Merksatz: Geschlossener Port heißt: Host kann erreichbar sein, Dienst aber nicht. --- **TCP und Paketmitschnitt** In einem Mitschnitt kann man TCP gut erkennen. Wichtige Hinweise: SYN SYN-ACK ACK RST FIN Retransmission Window Size Duplicate ACK Damit kann man sehen: Wird die Verbindung aufgebaut? Wo bleibt die Antwort aus? Wird zurückgesetzt? Gibt es Paketverlust? Merksatz: TCP lässt sich im Mitschnitt gut analysieren. --- **UDP und Paketmitschnitt** Bei UDP sieht man im Mitschnitt: Quell-Port Ziel-Port Länge Prüfsumme Nutzdaten Aber man sieht keinen Handshake. Deshalb muss man prüfen: Geht die Anfrage raus? Kommt eine Antwort zurück? Ist die Antwort korrekt? Wird etwas blockiert? Ist der Port richtig? Merksatz: Bei UDP vergleicht man Anfrage und Antwort. --- **TCP oder UDP bei Firewall-Regeln** Firewall-Regeln müssen das richtige Protokoll berücksichtigen. Beispiel: DNS erlauben Nicht ausreichend, wenn nur steht: Port 53 erlauben Genauer: UDP 53 erlauben TCP 53 bei Bedarf ebenfalls erlauben Beispiel HTTPS: TCP 443 erlauben Bei HTTP/3 kann zusätzlich relevant sein: UDP 443 erlauben Merksatz: Firewall-Regeln brauchen Protokoll und Port. --- **TCP oder UDP bei Portweiterleitungen** Auch Portweiterleitungen müssen das richtige Protokoll nutzen. Beispiel: Webserver klassisch: TCP 80 TCP 443 Beispiel DNS-Server: UDP 53 TCP 53 Beispiel Spielserver: je nach Spiel oft UDP oder TCP unterschiedlich Prüfungsfalle: TCP-Portweiterleitung hilft nicht, wenn der Dienst UDP nutzt. Merksatz: Portweiterleitung muss TCP oder UDP richtig treffen. --- **NAT/PAT und TCP/UDP** PAT nutzt Port-Zuordnungen. Bei TCP kann ein NAT-Gerät Verbindungszustände gut verfolgen. Bei UDP gibt es keinen echten Verbindungszustand. Deshalb nutzt NAT bei UDP Zeitfenster und Zuordnungstabellen. Wenn die Zuordnung abläuft, können Antworten verloren gehen. Merksatz: NAT verfolgt TCP leichter als UDP. --- **Typische Anwendungen und Transportprotokolle** | Anwendung / Dienst | typisches Transportprotokoll | |---|---| | HTTP | TCP | | HTTPS | TCP | | HTTP/3 | UDP | | SSH | TCP | | Telnet | TCP | | SMTP | TCP | | IMAP | TCP | | POP3 | TCP | | DNS | UDP und TCP | | DHCP | UDP | | NTP | UDP | | VoIP | häufig UDP | | Streaming | häufig UDP oder TCP je nach Technik | | VPN | je nach Lösung TCP oder UDP | Merksatz: Dienst immer mit Protokoll und Port betrachten. --- **TCP und UDP in der Praxisentscheidung** TCP ist sinnvoll, wenn wichtig ist: - Vollständigkeit - Reihenfolge - Zuverlässigkeit - fehlerfreie Dateiübertragung - stabile Verbindung UDP ist sinnvoll, wenn wichtig ist: - geringe Latenz - wenig Overhead - Echtzeitverhalten - kurze Anfragen - Anwendung übernimmt eigene Steuerung Merksatz: TCP für Genauigkeit. UDP für Geschwindigkeit und Echtzeit. --- **Einordnung in das OSI-Modell** | Thema | Schicht | |---|---:| | IP-Adresse | 3 | | Routing | 3 | | ICMP | 3 | | TCP | 4 | | UDP | 4 | | Port | 4 | | TCP-Handshake | 4 | | Sequenznummer | 4 | | ACK | 4 | | DNS-Dienst | 7, nutzt TCP/UDP 53 | | HTTP | 7, nutzt TCP | | HTTPS | 7, nutzt TCP und TLS | | HTTP/3 | 7, nutzt QUIC über UDP | Merksatz: TCP und UDP gehören zur Transportschicht. --- **Typische IHK-Fragen** In AP1 und AP2 kann zum Beispiel gefragt werden: - Was ist TCP? - Was ist UDP? - Worin unterscheiden sich TCP und UDP? - Was bedeutet verbindungsorientiert? - Was bedeutet verbindungslos? - Wie funktioniert der TCP-Drei-Wege-Handshake? - Was bedeuten SYN, SYN-ACK und ACK? - Warum ist TCP zuverlässig? - Warum ist UDP schneller beziehungsweise schlanker? - Wann eignet sich TCP? - Wann eignet sich UDP? - Warum nutzt DNS UDP und TCP? - Warum nutzt DHCP UDP? - Warum nutzen Echtzeitdienste häufig UDP? - Warum kann Ping funktionieren, aber TCP 443 nicht? - Warum muss eine Firewall zwischen TCP und UDP unterscheiden? --- **Typische Prüfungsfallen** TCP ist verbindungsorientiert. UDP ist verbindungslos. TCP nutzt den Drei-Wege-Handshake. UDP nutzt keinen Drei-Wege-Handshake. TCP bietet Zuverlässigkeit durch Bestätigungen und erneute Übertragung. UDP bietet keine eingebaute Zustellgarantie. TCP stellt Reihenfolge sicher. UDP stellt Reihenfolge nicht selbst sicher. TCP nutzt Segmente. UDP nutzt Datagramme. DNS nutzt UDP 53 und TCP 53. DHCP nutzt UDP 67 und 68. HTTP/3 nutzt QUIC über UDP. Gleiche Portnummer bei TCP und UDP ist technisch nicht dasselbe. Firewall-Regeln müssen TCP oder UDP korrekt angeben. Portweiterleitungen müssen TCP oder UDP korrekt treffen. Ping nutzt ICMP, nicht TCP oder UDP. --- **Wichtige Begriffe kurz erklärt** | Begriff | Kurze Erklärung | |---|---| | TCP | Transmission Control Protocol | | UDP | User Datagram Protocol | | verbindungsorientiert | Verbindung wird vor Datenübertragung aufgebaut | | verbindungslos | Daten werden ohne vorherige Verbindung gesendet | | SYN | Start einer TCP-Verbindung | | SYN-ACK | Antwort auf SYN mit Bestätigung | | ACK | Bestätigung | | Drei-Wege-Handshake | TCP-Verbindungsaufbau mit SYN, SYN-ACK, ACK | | Sequenznummer | Position von Daten im TCP-Strom | | Bestätigungsnummer | bestätigt empfangene Daten | | Retransmission | erneute Übertragung | | Flusskontrolle | schützt Empfänger vor Überlastung | | Staukontrolle | schützt Netzwerk vor Überlastung | | FIN | geordneter TCP-Verbindungsabbau | | RST | sofortiger TCP-Abbruch | | Timeout | erwartete Antwort bleibt zu lange aus | | Segment | TCP-Dateneinheit | | Datagramm | UDP-Dateneinheit | --- **IHK-sichere Kurzformulierung** TCP und UDP sind Transportprotokolle auf OSI-Schicht 4. TCP ist verbindungsorientiert und baut vor der Datenübertragung mit SYN, SYN-ACK und ACK eine Verbindung auf. Es bietet Zuverlässigkeit durch Bestätigungen, Sequenznummern, erneute Übertragung und Reihenfolgesicherung. UDP ist verbindungslos und sendet Datagramme ohne Verbindungsaufbau und ohne eingebaute Garantie für Zustellung oder Reihenfolge. Dadurch ist UDP schlanker und eignet sich gut für Echtzeitdienste oder kurze Anfragen. TCP- und UDP-Ports sind getrennt zu betrachten, auch wenn dieselbe Portnummer verwendet wird. --- **Merksätze** TCP = Transmission Control Protocol. UDP = User Datagram Protocol. Beide gehören zu Schicht 4. TCP ist verbindungsorientiert. UDP ist verbindungslos. TCP baut Verbindung auf. UDP sendet ohne Handshake. TCP-Handshake = SYN, SYN-ACK, ACK. TCP nutzt ACKs. TCP nutzt Sequenznummern. TCP kann erneut übertragen. TCP stellt Reihenfolge sicher. UDP bietet keine eingebaute Zustellgarantie. UDP ist schlanker als TCP. TCP = Segment. UDP = Datagramm. DNS nutzt UDP und TCP 53. DHCP nutzt UDP 67 und 68. HTTP/3 nutzt QUIC über UDP. Gleiche Portnummer bei TCP und UDP ist nicht dasselbe. Firewall-Regel braucht Protokoll und Port. TCP-Portweiterleitung hilft nicht bei UDP-Dienst. Ping ist ICMP, nicht TCP oder UDP. TCP für Zuverlässigkeit. UDP für geringe Verzögerung. # 7.3 Ports, Dienste und typische Standardports Ports gehören zu OSI-Schicht 4. Sie dienen dazu, Daten auf einem Gerät der richtigen Anwendung oder dem richtigen Dienst zuzuordnen. Eine IP-Adresse zeigt: zu welchem Gerät? Ein Port zeigt: zu welchem Dienst auf diesem Gerät? Beispiel: 192.168.10.50:443 Bedeutung: Gerät: 192.168.10.50 Dienst: Port 443 Merksatz: IP bringt zum Gerät. Port bringt zum Dienst. --- **Warum braucht man Ports?** Ein Server kann viele Dienste gleichzeitig anbieten. Beispiel: | Dienst | Port | |---|---:| | SSH | 22 | | DNS | 53 | | HTTP | 80 | | HTTPS | 443 | | RDP | 3389 | Alle Dienste können auf derselben IP-Adresse laufen. Die Portnummer entscheidet, welcher Dienst angesprochen wird. Merksatz: Mehrere Dienste auf einer IP-Adresse werden durch Ports unterschieden. --- **Portnummern** Portnummern sind 16 Bit groß. Deshalb gibt es Portnummern von: 0 bis: 65535 Insgesamt sind das: 65536 mögliche Werte Wichtig: TCP und UDP haben jeweils eigene Portbereiche. Das bedeutet: TCP 53 und UDP 53 sind technisch getrennte Kommunikationsmöglichkeiten. Merksatz: Portnummern gehen von 0 bis 65535. --- **TCP-Port und UDP-Port unterscheiden** Ein Port muss immer zusammen mit dem Transportprotokoll betrachtet werden. Beispiel: TCP 53 UDP 53 Beide können DNS betreffen, aber technisch sind sie nicht dasselbe. Eine Firewall-Regel für TCP 53 erlaubt nicht automatisch UDP 53. Eine Portweiterleitung für UDP 53 leitet nicht automatisch TCP 53 weiter. Merksatz: Portnummer immer mit TCP oder UDP nennen. --- **Portbereiche** Portnummern werden grob in drei Bereiche eingeteilt. | Bereich | Portnummern | Bedeutung | |---|---:|---| | Well-Known Ports | 0 – 1023 | bekannte Standarddienste | | Registered Ports | 1024 – 49151 | registrierte Anwendungsports | | Dynamic / Ephemeral Ports | 49152 – 65535 | temporäre Client-Ports | Merksatz: 0–1023 bekannt, 1024–49151 registriert, 49152–65535 temporär. --- **Well-Known Ports** Well-Known Ports sind bekannte Standardports. Sie werden für häufig genutzte Netzwerkdienste verwendet. Beispiele: | Dienst | Protokoll | Port | |---|---|---:| | FTP Steuerverbindung | TCP | 21 | | SSH | TCP | 22 | | Telnet | TCP | 23 | | SMTP | TCP | 25 | | DNS | TCP / UDP | 53 | | DHCP Server | UDP | 67 | | DHCP Client | UDP | 68 | | HTTP | TCP | 80 | | POP3 | TCP | 110 | | IMAP | TCP | 143 | | NTP | UDP | 123 | | HTTPS | TCP | 443 | Merksatz: Well-Known Ports sind prüfungsrelevant. --- **Registered Ports** Registered Ports liegen im Bereich: 1024 bis 49151 Sie werden häufig von Anwendungen, Herstellern oder Diensten genutzt. Beispiele: | Dienst / Anwendung | Protokoll | Port | |---|---|---:| | MySQL / MariaDB | TCP | 3306 | | RDP | TCP | 3389 | | PostgreSQL | TCP | 5432 | | VNC | TCP | 5900 | | HTTP-Alternative | TCP | 8080 | | HTTPS-Alternative | TCP | 8443 | Wichtig: Nicht jeder Port in diesem Bereich ist automatisch sicher oder unsicher. Entscheidend ist, welcher Dienst dort tatsächlich läuft. Merksatz: Registered Ports werden häufig von Anwendungen genutzt. --- **Dynamic oder Ephemeral Ports** Dynamic Ports werden auch Ephemeral Ports genannt. Sie liegen häufig im Bereich: 49152 bis 65535 Clients nutzen diese Ports meistens als temporäre Quell-Ports. Beispiel: Client: 192.168.10.20:52344 Server: 93.184.216.34:443 Der Client nutzt Port 52344 nur vorübergehend für diese Verbindung. Merksatz: Ephemeral Port = temporärer Client-Port. --- **Quell-Port und Ziel-Port** Ein TCP- oder UDP-Header enthält: Quell-Port Ziel-Port Beispiel HTTPS: Client: 192.168.10.20:52344 Server: 93.184.216.34:443 Dabei ist: 52344 = Quell-Port des Clients 443 = Ziel-Port des Servers Merksatz: Ziel-Port zeigt den gewünschten Dienst. Quell-Port hilft bei der Rückzuordnung. --- **Warum ist der Quell-Port wichtig?** Ein Client kann mehrere Verbindungen gleichzeitig öffnen. Beispiel: Browser-Tab 1 zu HTTPS Browser-Tab 2 zu HTTPS Update-Dienst zu HTTPS Cloud-Sync zu HTTPS Alle können zu Port 443 gehen. Der Client nutzt unterschiedliche Quell-Ports, damit Antworten korrekt zugeordnet werden. Merksatz: Quell-Ports unterscheiden gleichzeitige Verbindungen eines Clients. --- **Socket** Ein Socket besteht aus: IP-Adresse und Port Beispiel: 192.168.10.20:52344 Bei TCP-Verbindungen ist die Verbindung eindeutig über: Quell-IP Quell-Port Ziel-IP Ziel-Port Protokoll Beispiel: 192.168.10.20:52344 → 93.184.216.34:443 TCP Merksatz: Socket = IP-Adresse plus Port. --- **Dienst hört auf einem Port** Ein Dienst muss auf einem Port lauschen, damit Verbindungen oder Anfragen angenommen werden können. Beispiel: Webserver hört auf TCP 443. Das bedeutet: Der Dienst wartet auf HTTPS-Verbindungen. Wenn kein Dienst auf einem Port lauscht, ist der Port aus Sicht des Clients geschlossen. Merksatz: Dienst muss auf dem Port lauschen. --- **LISTEN und ESTABLISHED** Bei TCP sind zwei Zustände besonders wichtig. | Zustand | Bedeutung | |---|---| | LISTEN | Dienst wartet auf eingehende Verbindungen | | ESTABLISHED | Verbindung besteht | Beispiel: Webserver im Zustand LISTEN auf TCP 443 bedeutet: Der Webserver wartet auf HTTPS-Verbindungen. Merksatz: LISTEN = Dienst wartet. ESTABLISHED = Verbindung steht. --- **Offener Port** Ein Port ist offen, wenn ein Dienst dort erreichbar ist. Beispiel: TCP 443 offen Bedeutung: Ein Dienst nimmt TCP-Verbindungen auf Port 443 an. Aber: Ein offener Port beweist nicht automatisch, dass die Anwendung korrekt funktioniert. Merksatz: Offener Port = Dienst grundsätzlich erreichbar. --- **Geschlossener Port** Ein Port ist geschlossen, wenn kein Dienst auf diesem Port lauscht. Beispiel: Server ist per Ping erreichbar. TCP 22 ist geschlossen. Bedeutung: Der Host ist erreichbar, aber SSH läuft dort nicht oder nicht auf Port 22. Merksatz: Geschlossener Port heißt nicht: Gerät ist offline. --- **Gefilterter Port** Ein Port wirkt gefiltert, wenn eine Firewall Pakete blockiert oder verwirft. Typisch: keine klare Antwort Timeout Verbindung bleibt hängen Mögliche Ursachen: - Firewall blockiert - Paketfilter verwirft still - NAT-Regel fehlt - Rückweg fehlt - Security-Gruppe blockiert Merksatz: Gefiltert bedeutet häufig: Firewall oder Paketfilter im Weg. --- **Portstatus im Vergleich** | Status | Bedeutung | |---|---| | offen | Dienst antwortet oder nimmt Verbindung an | | geschlossen | Host erreichbar, aber kein Dienst auf diesem Port | | gefiltert | keine klare Antwort, oft Firewall | | offen, aber Anwendung fehlerhaft | Port erreichbar, Dienstproblem auf höherer Schicht | Merksatz: Portstatus hilft, Schicht 4 von höheren Schichten zu trennen. --- **Wichtige Standardports** | Dienst | Protokoll | Port | Zweck | |---|---|---:|---| | FTP | TCP | 21 | Dateiübertragung Steuerverbindung | | SSH | TCP | 22 | sicherer Fernzugriff | | Telnet | TCP | 23 | unsicherer Fernzugriff | | SMTP | TCP | 25 | E-Mail-Versand zwischen Servern | | DNS | TCP / UDP | 53 | Namensauflösung | | DHCP Server | UDP | 67 | IP-Konfiguration anbieten | | DHCP Client | UDP | 68 | IP-Konfiguration empfangen | | HTTP | TCP | 80 | unverschlüsselte Webübertragung | | POP3 | TCP | 110 | E-Mail-Abruf | | NTP | UDP | 123 | Zeitsynchronisation | | IMAP | TCP | 143 | E-Mail-Abruf und Verwaltung | | HTTPS | TCP | 443 | verschlüsselte Webübertragung | | RDP | TCP | 3389 | Windows-Remote-Desktop | Merksatz: HTTP 80, HTTPS 443, SSH 22, DNS 53, DHCP 67/68. --- **FTP** FTP steht für: File Transfer Protocol Typischer Port: TCP 21 FTP dient der Dateiübertragung. Wichtig: Klassisches FTP ist unverschlüsselt. Benutzername, Passwort und Daten können ohne Schutz übertragen werden. Sichere Alternativen sind zum Beispiel: SFTP FTPS Merksatz: FTP = TCP 21, klassisch unverschlüsselt. --- **SSH** SSH steht für: Secure Shell Typischer Port: TCP 22 SSH wird genutzt für: - sicheren Fernzugriff - Administration von Servern - sichere Kommandozeile - Tunnel - Dateiübertragung über SFTP Merksatz: SSH = TCP 22, verschlüsselter Fernzugriff. --- **Telnet** Telnet nutzt typischerweise: TCP 23 Telnet ist ein älteres Fernzugriffsprotokoll. Problem: Telnet ist unverschlüsselt. Deshalb sollte Telnet in modernen Netzwerken nicht für administrative Zugriffe verwendet werden. Merksatz: Telnet = TCP 23, unsicher und unverschlüsselt. --- **SMTP** SMTP steht für: Simple Mail Transfer Protocol Typischer Port: TCP 25 SMTP wird für den E-Mail-Transport verwendet, besonders zwischen Mailservern. Weitere Mailports können sein: 587 für Mail Submission 465 für SMTPS Für AP1/AP2 ist besonders wichtig: SMTP = Mailversand Merksatz: SMTP = E-Mail-Versand. --- **POP3** POP3 steht für: Post Office Protocol Version 3 Typischer Port: TCP 110 POP3 dient dem Abruf von E-Mails. Häufig werden Mails dabei vom Server heruntergeladen. Verschlüsselte Variante: POP3S über TCP 995 Merksatz: POP3 = E-Mail-Abruf. --- **IMAP** IMAP steht für: Internet Message Access Protocol Typischer Port: TCP 143 IMAP dient ebenfalls dem Abruf und der Verwaltung von E-Mails. Im Unterschied zu POP3 bleiben Mails häufig auf dem Server und werden zwischen Geräten synchronisiert. Verschlüsselte Variante: IMAPS über TCP 993 Merksatz: IMAP = E-Mail-Verwaltung auf dem Server. --- **SMTP, POP3 und IMAP unterscheiden** | Protokoll | Richtung / Zweck | typischer Port | |---|---|---:| | SMTP | E-Mail senden / transportieren | TCP 25 | | POP3 | E-Mail abrufen | TCP 110 | | IMAP | E-Mail abrufen und verwalten | TCP 143 | Merksatz: SMTP sendet. POP3 und IMAP holen ab. --- **DNS** DNS steht für: Domain Name System DNS ordnet Namen IP-Adressen zu. Typischer Port: UDP 53 DNS kann auch nutzen: TCP 53 Beispiele für TCP bei DNS: - große Antworten - Zonentransfers - bestimmte DNSSEC-Fälle Merksatz: DNS = UDP 53 häufig, TCP 53 ebenfalls möglich. --- **DHCP** DHCP steht für: Dynamic Host Configuration Protocol DHCP vergibt automatisch IP-Konfigurationen. Wichtige Ports: | Rolle | Protokoll | Port | |---|---|---:| | DHCP-Server | UDP | 67 | | DHCP-Client | UDP | 68 | DHCP vergibt zum Beispiel: - IP-Adresse - Subnetzmaske - Gateway - DNS-Server Merksatz: DHCP = UDP 67 und 68. --- **HTTP** HTTP steht für: Hypertext Transfer Protocol Typischer Port: TCP 80 HTTP wird für Webseiten und Webdienste verwendet. Wichtig: HTTP ist unverschlüsselt. Heute wird für Webseiten meist HTTPS bevorzugt. Merksatz: HTTP = TCP 80, unverschlüsselt. --- **HTTPS** HTTPS steht für: Hypertext Transfer Protocol Secure Typischer Port: TCP 443 HTTPS nutzt Verschlüsselung über TLS. HTTPS schützt unter anderem: - Vertraulichkeit - Integrität - Serverauthentizität über Zertifikate Merksatz: HTTPS = TCP 443, HTTP mit TLS-Verschlüsselung. --- **NTP** NTP steht für: Network Time Protocol Typischer Port: UDP 123 NTP dient zur Zeitsynchronisation. Warum wichtig? Viele IT-Funktionen benötigen korrekte Zeit. Beispiele: - Zertifikate - Kerberos - Logs - Monitoring - Dateisynchronisation Merksatz: NTP = UDP 123, Zeitsynchronisation. --- **RDP** RDP steht für: Remote Desktop Protocol Typischer Port: TCP 3389 RDP wird häufig für grafischen Fernzugriff auf Windows-Systeme genutzt. Wichtig: RDP sollte nicht ungeschützt direkt ins Internet geöffnet werden. Besser: VPN Zugriffsbeschränkung Multi-Faktor-Authentifizierung sichere Gateway-Lösungen Merksatz: RDP = TCP 3389, Fernzugriff sorgfältig absichern. --- **Sichere und unsichere Protokolle** Einige ältere Protokolle übertragen Daten unverschlüsselt. | eher unsicher / unverschlüsselt | sicherere Alternative | |---|---| | Telnet | SSH | | FTP | SFTP oder FTPS | | HTTP | HTTPS | | POP3 | POP3S | | IMAP | IMAPS | | SMTP ohne TLS | SMTP mit STARTTLS oder SMTPS | Merksatz: Für Administration und sensible Daten verschlüsselte Protokolle nutzen. --- **Ports und Firewall-Regeln** Firewalls arbeiten häufig mit IP-Adressen und Ports. Beispiel-Regel: Erlaube TCP 443 von Client-Netz zum Internet Bedeutung: HTTPS-Verbindungen nach außen sind erlaubt. Andere Ports können weiterhin blockiert sein. Merksatz: Firewall-Regel = Quelle, Ziel, Protokoll, Port, Aktion. --- **Firewall-Regel vollständig denken** Eine sinnvolle Firewall-Regel enthält: - Quelle - Ziel - Protokoll - Port - Richtung - Aktion - Kommentar oder Zweck Beispiel: Quelle: Mitarbeiter-VLAN Ziel: Internet Protokoll: TCP Port: 443 Aktion: erlauben Merksatz: Nicht nur Port nennen, sondern Quelle, Ziel und Protokoll. --- **TCP und UDP bei Firewall-Regeln** Ports müssen bei Firewalls mit TCP oder UDP angegeben werden. Beispiel DNS: UDP 53 erlauben TCP 53 erlauben, wenn benötigt Beispiel HTTPS: TCP 443 erlauben Beispiel HTTP/3: UDP 443 kann zusätzlich relevant sein Prüfungsfalle: TCP 53 erlaubt nicht automatisch UDP 53. Merksatz: Firewall-Regeln brauchen Protokoll und Port. --- **Ports und Portweiterleitung** Bei Portweiterleitungen muss ebenfalls das richtige Protokoll gewählt werden. Beispiel Webserver: TCP 80 TCP 443 Beispiel DNS-Server: UDP 53 TCP 53 Beispiel Spielserver: je nach Anwendung TCP oder UDP Merksatz: Portweiterleitung muss TCP oder UDP korrekt treffen. --- **Portweiterleitung und Dienst** Eine Portweiterleitung funktioniert nur, wenn mehrere Dinge passen. Prüfpunkte: - öffentliche Erreichbarkeit vorhanden? - kein CGNAT? - externer Port korrekt? - internes Ziel korrekt? - internes Ziel hört auf dem Port? - Firewall erlaubt? - Dienst läuft? - DNS zeigt auf richtige IP? Merksatz: Portweiterleitung reicht nicht, wenn der Dienst nicht läuft oder blockiert wird. --- **Ports und NAT/PAT** PAT nutzt Port-Zuordnungen. Beispiel: | Intern | Extern | |---|---| | 192.168.10.20:52344 | 93.184.100.10:40001 | | 192.168.10.30:52344 | 93.184.100.10:40002 | Dadurch können mehrere interne Geräte dieselbe öffentliche IP-Adresse nutzen. Merksatz: PAT unterscheidet Verbindungen über Ports. --- **Ports und Dienste prüfen** Typische Fragen bei der Prüfung eines Dienstes: Ist der Host per IP erreichbar? Ist der richtige Port offen? Nutzt der Dienst TCP oder UDP? Läuft der Dienst wirklich? Hört der Dienst auf der richtigen Schnittstelle? Blockiert eine Firewall? Gibt es NAT oder Portweiterleitung? Ist die Anwendung korrekt konfiguriert? Merksatz: Dienstproblem = IP, Port, Protokoll, Firewall und Anwendung prüfen. --- **Ping und Porttest unterscheiden** Ping nutzt ICMP. Ping prüft keine TCP- oder UDP-Ports. Beispiel: ping server funktioniert Das bedeutet nicht automatisch: TCP 443 ist offen. Um Ports zu prüfen, braucht man andere Tests. Beispiele sinngemäß: Verbindung zu TCP-Port testen Dienstabfrage durchführen Portscan kontrolliert einsetzen Logs prüfen Merksatz: Ping prüft IP. Porttest prüft Schicht 4. --- **Portscan** Ein Portscan prüft, welche Ports auf einem Ziel erreichbar sind. Er kann nützlich sein für: - Administration - Fehlersuche - Sicherheitsprüfung - Inventarisierung Aber: Portscans dürfen nur in erlaubten Netzen durchgeführt werden. Unberechtigte Scans können als Angriff gewertet werden. Merksatz: Portscan nur mit Berechtigung durchführen. --- **Port offen heißt nicht automatisch sicher** Ein offener Port bedeutet: Dort ist ein Dienst erreichbar. Das sagt noch nicht: ob der Dienst sicher konfiguriert ist ob er aktuell ist ob die Authentifizierung stark ist ob Schwachstellen vorhanden sind Beispiel: SSH offen kann normal sein. SSH mit schwachem Passwort ist gefährlich. Merksatz: Sicherheit hängt nicht nur vom Port, sondern vom Dienst ab. --- **Port geschlossen heißt nicht automatisch geschützt** Ein geschlossener Port bedeutet: Auf diesem Port lauscht aktuell kein Dienst. Aber: andere Ports können offen sein. Dienste können später gestartet werden. Firewall-Regeln können sich ändern. interne Angriffe können andere Wege nutzen. Merksatz: Geschlossene Ports sind gut, ersetzen aber kein Sicherheitskonzept. --- **Prinzip: Nur notwendige Ports öffnen** Ein wichtiges Sicherheitsprinzip lautet: Nur notwendige Dienste und Ports freigeben. Das reduziert die Angriffsfläche. Beispiele: SSH nur für Admin-Netz erlauben. Datenbank nicht direkt ins Internet öffnen. RDP nur über VPN bereitstellen. Webserver nur mit benötigten Ports freigeben. Gastnetz von internen Diensten trennen. Merksatz: Weniger offene Ports = kleinere Angriffsfläche. --- **Typische Port-Fehler** Typische Fehler sind: - falscher Port - falsches Protokoll TCP statt UDP - falsches Protokoll UDP statt TCP - Dienst läuft nicht - Dienst hört nur auf localhost - Firewall blockiert - NAT-Regel fehlt - Portweiterleitung falsch - DNS zeigt auf falschen Server - Reverse Proxy nutzt falschen Zielport - Client nutzt alten Port Merksatz: Portprobleme sind oft Konfigurationsfehler zwischen Dienst, Firewall und NAT. --- **Beispiel: HTTPS funktioniert nicht** Fehlerbild: Server ist per Ping erreichbar. Webseite öffnet nicht über HTTPS. Mögliche Ursachen: - TCP 443 geschlossen - Firewall blockiert TCP 443 - Webserver läuft nicht - Webserver hört auf anderem Port - TLS-Zertifikat fehlerhaft - Reverse Proxy falsch - DNS zeigt auf falsche IP - NAT-Portweiterleitung falsch Merksatz: Ping geht, HTTPS nicht: TCP 443 und Anwendung prüfen. --- **Beispiel: DNS funktioniert nicht** Fehlerbild: Internet-IP ist erreichbar. Namen werden nicht aufgelöst. Mögliche Ursachen: - DNS-Server falsch - UDP 53 blockiert - TCP 53 blockiert bei großen Antworten - DNS-Dienst läuft nicht - Firewall blockiert - falsche DNS-Zone - DNS-Cache fehlerhaft Merksatz: DNS braucht Namensdienst und passende Ports. --- **Beispiel: DHCP funktioniert nicht** Fehlerbild: Client bekommt keine IP-Adresse. Mögliche Ursachen: - DHCP-Server nicht erreichbar - UDP 67/68 blockiert - falsches VLAN - DHCP-Relay fehlt - DHCP-Bereich erschöpft - DHCP-Dienst läuft nicht - Trunk transportiert VLAN nicht Merksatz: DHCP-Probleme können Schicht 2, 3, 4 und 7 berühren. --- **Beispiel: SSH funktioniert nicht** Fehlerbild: Server ist erreichbar, aber SSH-Verbindung klappt nicht. Mögliche Ursachen: - TCP 22 geschlossen - SSH-Dienst läuft nicht - Firewall blockiert - SSH hört auf anderem Port - Zugriff nur aus bestimmten Netzen erlaubt - Benutzer oder Schlüssel falsch - Fail2ban oder Schutzsystem blockiert Merksatz: SSH braucht TCP-Port, laufenden Dienst und gültige Anmeldung. --- **Einordnung in das OSI-Modell** | Thema | Schicht | |---|---:| | IP-Adresse | 3 | | Routing | 3 | | TCP | 4 | | UDP | 4 | | Port | 4 | | Socket | 4 mit IP-Bezug | | DNS-Dienst | 7, nutzt TCP/UDP 53 | | DHCP-Dienst | 7, nutzt UDP 67/68 | | HTTP | 7, nutzt TCP 80 | | HTTPS | 7, nutzt TCP 443 | | SSH | 7, nutzt TCP 22 | | Firewall nach Port | 3 / 4 | | NAT/PAT | 3 / 4 | Merksatz: Port = Schicht 4. Dienst = höhere Schicht. --- **Was Ports nicht leisten** Ports lösen nicht automatisch: - Namensauflösung - Authentifizierung - Verschlüsselung - Benutzerrechte - Dienstkonfiguration - Zertifikatsprüfung - Anwendungslogik - Routing - VLAN-Zuordnung Ports sagen nur: welcher Dienst angesprochen werden soll. Merksatz: Port erreichbar heißt nicht: Anwendung korrekt. --- **Typische IHK-Fragen** In AP1 und AP2 kann zum Beispiel gefragt werden: - Was ist ein Port? - Warum braucht man Ports? - Was ist der Unterschied zwischen IP-Adresse und Port? - Was ist der Unterschied zwischen Switch-Port und TCP-Port? - In welchem Bereich liegen Portnummern? - Was sind Well-Known Ports? - Was sind Ephemeral Ports? - Welche Ports nutzen HTTP, HTTPS, SSH, DNS und DHCP? - Warum muss man bei Portfreigaben TCP und UDP unterscheiden? - Was bedeutet offener, geschlossener oder gefilterter Port? - Warum kann Ping funktionieren, aber ein Dienst nicht? - Warum sollte man nur notwendige Ports öffnen? --- **Typische Prüfungsfallen** Port gehört zu Schicht 4. Dienst gehört zu höheren Schichten. IP-Adresse zeigt zum Gerät. Port zeigt zum Dienst. Switch-Port ist nicht TCP-Port. TCP-Port und UDP-Port sind getrennt. Portnummern gehen von 0 bis 65535. Well-Known Ports = 0 bis 1023. Ephemeral Ports = temporäre Client-Ports. HTTP = TCP 80. HTTPS = TCP 443. SSH = TCP 22. DNS = UDP 53 und TCP 53. DHCP = UDP 67 und 68. NTP = UDP 123. RDP = TCP 3389. Ping nutzt ICMP und prüft keine Ports. Firewall-Regeln brauchen Protokoll und Port. Portweiterleitung braucht richtiges Protokoll. Offener Port bedeutet nicht automatisch sichere Anwendung. --- **Wichtige Begriffe kurz erklärt** | Begriff | Kurze Erklärung | |---|---| | Port | logische Dienstnummer auf Schicht 4 | | TCP-Port | Port für TCP-Kommunikation | | UDP-Port | Port für UDP-Kommunikation | | Switch-Port | physischer Anschluss am Switch | | Quell-Port | Port des Absenders | | Ziel-Port | Port des gewünschten Dienstes | | Socket | IP-Adresse plus Port | | Well-Known Port | Port 0 bis 1023 | | Registered Port | Port 1024 bis 49151 | | Ephemeral Port | temporärer Client-Port | | LISTEN | Dienst wartet auf Verbindung | | ESTABLISHED | Verbindung besteht | | offener Port | Dienst erreichbar | | geschlossener Port | kein Dienst lauscht | | gefilterter Port | Firewall oder Filter blockiert | | Portweiterleitung | externer Port wird intern weitergeleitet | | Portscan | Prüfung erreichbarer Ports | --- **IHK-sichere Kurzformulierung** Ports sind logische Dienstnummern auf OSI-Schicht 4. Sie werden zusammen mit TCP oder UDP verwendet, um Daten auf einem Gerät dem richtigen Dienst zuzuordnen. Eine IP-Adresse identifiziert das Gerät, der Port identifiziert den Dienst auf diesem Gerät. Portnummern reichen von 0 bis 65535 und werden in Well-Known Ports, Registered Ports und Dynamic beziehungsweise Ephemeral Ports eingeteilt. TCP- und UDP-Ports sind getrennt zu betrachten. Firewall-Regeln und Portweiterleitungen müssen deshalb immer das richtige Protokoll und den richtigen Port berücksichtigen. --- **Merksätze** Port = logische Dienstnummer. Port gehört zu Schicht 4. IP bringt zum Gerät. Port bringt zum Dienst. Switch-Port ist physisch. TCP-/UDP-Port ist logisch. TCP-Port und UDP-Port sind nicht dasselbe. Portnummern gehen von 0 bis 65535. Well-Known Ports = 0 bis 1023. Registered Ports = 1024 bis 49151. Ephemeral Ports = 49152 bis 65535. Ziel-Port zeigt den Dienst. Quell-Port hilft bei der Rückzuordnung. Socket = IP-Adresse plus Port. LISTEN = Dienst wartet. ESTABLISHED = Verbindung steht. HTTP = TCP 80. HTTPS = TCP 443. SSH = TCP 22. DNS = UDP 53 und TCP 53. DHCP = UDP 67 und 68. NTP = UDP 123. RDP = TCP 3389. Ping prüft keine Ports. Firewall-Regel braucht Quelle, Ziel, Protokoll und Port. Portweiterleitung braucht richtiges Protokoll. Nur notwendige Ports öffnen. Offener Port heißt nicht automatisch sicher. Port erreichbar heißt nicht automatisch: Anwendung funktioniert. # 7.4 Fehlersuche auf Schicht 4 Fehler auf OSI-Schicht 4 betreffen den Transport zwischen Anwendungen. Dabei geht es vor allem um: - TCP - UDP - Ports - Verbindungsaufbau - Verbindungszustände - Firewall-Regeln - Portweiterleitungen - NAT/PAT - Timeouts - Resets - Dienst-Erreichbarkeit Schicht 4 liegt zwischen: Schicht 3: IP, Routing, Gateway und Schicht 5 bis 7: Sitzung, Darstellung, Anwendung Merksatz: Schicht-4-Fehlersuche = TCP, UDP und Ports prüfen. --- **Grundidee der Schicht-4-Fehlersuche** Auf Schicht 3 prüft man: Ist das Zielgerät per IP erreichbar? Auf Schicht 4 prüft man: Ist der gewünschte Dienst-Port erreichbar? Beispiel: Server per Ping erreichbar: ja HTTPS auf TCP 443 erreichbar: nein Dann ist die reine IP-Erreichbarkeit nicht das Problem. Man muss TCP-Port, Firewall, Dienst oder Portweiterleitung prüfen. Merksatz: IP erreichbar heißt nicht automatisch: Port erreichbar. --- **Schicht 3 und Schicht 4 unterscheiden** | Frage | Schicht | |---|---:| | Hat der Client eine IP-Adresse? | 3 | | Ist das Gateway erreichbar? | 3 | | Gibt es eine Route zum Ziel? | 3 | | Funktioniert Ping auf die IP? | 3 | | Ist TCP 443 offen? | 4 | | Ist UDP 53 erreichbar? | 4 | | Kommt der TCP-Handshake zustande? | 4 | | Läuft der Webdienst korrekt? | 7 | Merksatz: IP = Schicht 3. Port = Schicht 4. Dienstinhalt = Schicht 7. --- **Typische Schicht-4-Fehler** Typische Fehler auf Schicht 4 sind: - falscher Ziel-Port - falsches Protokoll TCP statt UDP - falsches Protokoll UDP statt TCP - Dienst lauscht nicht - Dienst lauscht auf anderer IP-Adresse - Dienst lauscht auf anderem Port - Firewall blockiert TCP oder UDP - TCP-Handshake scheitert - TCP Reset - Timeout - NAT/PAT-Zuordnung falsch - Portweiterleitung falsch - Rückweg fehlt - UDP-Antwort kommt nicht zurück Merksatz: Schicht-4-Fehler betreffen Erreichbarkeit von TCP- oder UDP-Diensten. --- **Reihenfolge bei der Fehlersuche** Eine sinnvolle Reihenfolge ist: 1. Schicht 1 prüfen: Link, Kabel, Signal 2. Schicht 2 prüfen: MAC, VLAN, ARP 3. Schicht 3 prüfen: IP, Gateway, Routing 4. Schicht 4 prüfen: TCP, UDP, Port 5. Schicht 7 prüfen: Anwendung, DNS, Authentifizierung, Zertifikat Merksatz: Erst IP-Erreichbarkeit prüfen, dann Port-Erreichbarkeit prüfen. --- **Fehlerbild: Ping funktioniert, Dienst funktioniert nicht** Beispiel: ping server funktioniert Aber: Webseite über HTTPS funktioniert nicht. Dann ist das Zielgerät grundsätzlich per IP erreichbar. Mögliche Ursachen: - TCP 443 geschlossen - Firewall blockiert TCP 443 - Webserver läuft nicht - Webserver hört auf anderem Port - Dienst hört nur auf localhost - Reverse Proxy falsch - TLS-Zertifikat fehlerhaft - Anwendung abgestürzt Merksatz: Ping geht, Dienst nicht: Schicht 4 und Schicht 7 prüfen. --- **Fehlerbild: Port geschlossen** Ein Port ist geschlossen, wenn kein Dienst auf diesem Port lauscht. Beispiel: Server erreichbar, aber TCP 22 geschlossen. Bedeutung: Der Host ist erreichbar, aber SSH läuft dort nicht oder SSH nutzt einen anderen Port. Mögliche Ursachen: - Dienst nicht gestartet - Dienst deaktiviert - falscher Port - Dienst hört nur auf anderer Schnittstelle - Konfigurationsfehler - Dienst abgestürzt Merksatz: Geschlossener Port heißt: Host kann erreichbar sein, Dienst aber nicht. --- **Fehlerbild: Port gefiltert** Ein Port wirkt gefiltert, wenn keine klare Antwort kommt. Typisches Verhalten: Timeout keine Rückmeldung Verbindung bleibt hängen Mögliche Ursachen: - Firewall verwirft Pakete - Paketfilter blockiert - Security-Gruppe blockiert - NAT-Regel fehlt - Rückroute fehlt - Provider blockiert Port Merksatz: Gefilterter Port bedeutet oft: Firewall oder Filter im Weg. --- **Fehlerbild: Port offen, Anwendung funktioniert trotzdem nicht** Ein offener Port bedeutet nur: Ein Dienst nimmt Verbindungen an oder antwortet auf Anfragen. Das bedeutet nicht automatisch: Anwendung ist korrekt konfiguriert. Anmeldung funktioniert. Zertifikat ist gültig. Datenbank ist erreichbar. Webanwendung läuft fehlerfrei. Beispiel: TCP 443 offen, aber Webseite zeigt Fehler 500. Dann ist Schicht 4 grundsätzlich erreichbar, aber die Anwendung auf höherer Schicht hat ein Problem. Merksatz: Port offen heißt nicht: Anwendung korrekt. --- **Fehlerbild: TCP-Handshake scheitert** Der TCP-Verbindungsaufbau besteht aus: SYN SYN-ACK ACK Wenn dieser Handshake nicht vollständig zustande kommt, kann keine TCP-Verbindung aufgebaut werden. Mögliche Ursachen: - SYN kommt nicht beim Server an - Server antwortet nicht mit SYN-ACK - SYN-ACK kommt nicht zum Client zurück - Firewall blockiert eine Richtung - NAT oder Portweiterleitung falsch - Dienst lauscht nicht - Rückroute fehlt Merksatz: Kein vollständiger TCP-Handshake = keine TCP-Verbindung. --- **Fehlerbild: SYN ohne SYN-ACK** Wenn der Client SYN sendet, aber kein SYN-ACK zurückkommt, gibt es mehrere Möglichkeiten. Mögliche Ursachen: - Server nicht erreichbar - Firewall blockiert SYN - Firewall blockiert SYN-ACK - Dienst lauscht nicht - Paket geht auf dem Weg verloren - NAT-Regel fehlt - Rückroute fehlt Wichtig: Ohne Mitschnitt oder Logs sieht man oft nur einen Timeout. Merksatz: SYN ohne Antwort deutet oft auf Filter, Routing oder Dienstproblem hin. --- **Fehlerbild: TCP Reset** TCP Reset wird mit RST gekennzeichnet. RST bedeutet: Verbindung sofort abbrechen. Mögliche Ursachen: - Port geschlossen - Dienst lehnt Verbindung ab - Anwendung beendet Verbindung - Firewall sendet Reset - falsches Protokoll auf richtigem Port - Server akzeptiert Verbindung nicht Merksatz: RST = Verbindung wird aktiv zurückgesetzt. --- **Fehlerbild: TCP Timeout** Timeout bedeutet: Eine erwartete Antwort kommt nicht rechtzeitig. Mögliche Ursachen: - Firewall verwirft still - Server antwortet nicht - Rückweg fehlt - NAT-Zuordnung fehlt - Netzwerkverlust - Dienst überlastet - falsche Zieladresse - falscher Port Merksatz: Timeout = keine rechtzeitige Antwort. --- **Fehlerbild: Verbindung wird langsam** Eine TCP-Verbindung kann funktionieren, aber sehr langsam sein. Mögliche Ursachen: - Paketverlust - viele Retransmissions - hohe Latenz - MTU-Probleme - Überlastung - zu kleine TCP-Fenstergröße - Staukontrolle greift - Firewall oder Proxy bremst Merksatz: Langsame TCP-Verbindung kann Paketverlust oder MTU-Problem bedeuten. --- **Fehlerbild: TCP Retransmissions** Retransmission bedeutet: TCP sendet Daten erneut. Das passiert, wenn TCP annimmt, dass Daten verloren gegangen sind. Mögliche Ursachen: - Paketverlust - Überlastung - schlechte Verbindung - fehlerhafte Netzkomponente - MTU-Probleme - Funkprobleme - Duplex- oder Linkproblem Merksatz: Viele Retransmissions deuten auf Übertragungsprobleme hin. --- **Fehlerbild: UDP-Dienst antwortet nicht** UDP hat keinen Verbindungsaufbau. Wenn ein UDP-Dienst nicht antwortet, ist die Ursache oft schwerer zu erkennen. Mögliche Ursachen: - falscher UDP-Port - Dienst läuft nicht - Firewall blockiert UDP - Antwortweg fehlt - NAT-Zuordnung abgelaufen - Anfrage ist ungültig - Dienst antwortet nur auf bestimmte Quellen - Paketverlust Merksatz: UDP-Probleme brauchen oft Logs oder Mitschnitt. --- **TCP und UDP bei Firewalls** Firewalls unterscheiden zwischen TCP und UDP. Beispiel DNS: UDP 53 TCP 53 Wenn nur TCP 53 erlaubt ist, funktionieren normale DNS-Anfragen über UDP möglicherweise nicht. Wenn nur UDP 53 erlaubt ist, können große DNS-Antworten oder Zonentransfers scheitern. Merksatz: Firewall-Regel muss Protokoll und Port korrekt enthalten. --- **Fehlerbild: Falsches Protokoll** Ein häufiger Fehler ist: TCP erlaubt, aber Dienst nutzt UDP Oder: UDP weitergeleitet, aber Dienst nutzt TCP Beispiel: DNS benötigt häufig UDP 53. Nur TCP 53 wurde freigegeben. Folge: DNS funktioniert nicht oder nur teilweise. Merksatz: Richtige Portnummer reicht nicht, TCP oder UDP muss ebenfalls stimmen. --- **Fehlerbild: Portweiterleitung funktioniert nicht** Eine Portweiterleitung leitet einen externen Port an ein internes Ziel weiter. Mögliche Fehler: - falscher externer Port - falscher interner Port - falsche interne IP-Adresse - falsches Protokoll TCP/UDP - Dienst läuft intern nicht - Firewall blockiert am Router - Firewall blockiert am Server - CGNAT beim Provider - DNS zeigt auf falsche öffentliche IP - Hairpin NAT fehlt bei internem Test Merksatz: Portweiterleitung braucht richtige IP, richtigen Port, richtiges Protokoll und laufenden Dienst. --- **Fehlerbild: Dienst hört nur auf localhost** Ein Dienst kann so konfiguriert sein, dass er nur lokal erreichbar ist. Beispiel: Dienst hört auf: 127.0.0.1:8080 Dann ist er nur vom eigenen Gerät aus erreichbar. Von anderen Geräten im Netzwerk funktioniert der Zugriff nicht. Richtig wäre je nach Bedarf zum Beispiel: 0.0.0.0:8080 oder konkrete Server-IP:8080 Merksatz: localhost bedeutet: nur lokal auf dem eigenen Gerät. --- **Fehlerbild: Dienst hört auf falscher Schnittstelle** Ein Server kann mehrere IP-Adressen haben. Beispiel: 192.168.10.50 10.0.0.50 Ein Dienst kann nur auf einer dieser Adressen lauschen. Wenn Clients die andere IP-Adresse nutzen, ist der Dienst dort nicht erreichbar. Merksatz: Dienst muss auf der richtigen IP-Adresse lauschen. --- **Fehlerbild: Dienst nutzt anderen Port** Ein Dienst kann auf einem anderen Port konfiguriert sein als erwartet. Beispiele: Weboberfläche auf TCP 8080 statt TCP 80 HTTPS auf TCP 8443 statt TCP 443 SSH auf TCP 2222 statt TCP 22 Dann schlägt der Zugriff auf den Standardport fehl. Merksatz: Standardport prüfen, aber tatsächliche Dienstkonfiguration beachten. --- **Fehlerbild: Firewall auf dem Server blockiert** Auch wenn Netzwerk und Router korrekt sind, kann die lokale Firewall auf dem Server blockieren. Mögliche Systeme: Windows Defender Firewall Linux-Firewall Host-Firewall Sicherheitssoftware Cloud-Security-Groups Typische Prüfung: Ist der Dienst lokal erreichbar? Ist der Port auf dem Server erlaubt? Darf die Client-Quelle zugreifen? Merksatz: Nicht nur Netzwerk-Firewall prüfen, auch Host-Firewall prüfen. --- **Fehlerbild: Stateful Firewall blockiert** Eine Stateful Firewall merkt sich Verbindungszustände. Bei TCP kann sie den Handshake und bestehende Verbindungen verfolgen. Probleme entstehen bei: - asymmetrischem Routing - fehlender Rückroute - NAT über anderen Weg - ungültigen TCP-Zuständen - Verbindung läuft über andere Firewall zurück Merksatz: Stateful Firewall muss Hin- und Rückrichtung richtig sehen. --- **Fehlerbild: NAT/PAT-Zuordnung fehlt** Bei PAT werden Verbindungen über Ports zugeordnet. Wenn die Zuordnung fehlt oder abläuft, kann Rückverkehr nicht richtig zugestellt werden. Besonders bei UDP kann das auftreten, weil UDP keinen echten Verbindungszustand hat. Mögliche Folgen: - Antwort kommt nicht an - Verbindung bricht ab - Dienst wirkt instabil Merksatz: PAT braucht passende Port-Zuordnung für den Rückverkehr. --- **Fehlerbild: MTU-Problem wirkt wie Schicht-4-Problem** Manchmal funktionieren kleine Verbindungen, aber größere Datenübertragungen hängen. Mögliche Ursache: MTU-Problem Symptome: Ping mit kleiner Größe funktioniert. Webseite lädt teilweise. VPN funktioniert instabil. Dateiübertragung bleibt hängen. TLS-Verbindung hängt beim Aufbau. Obwohl die Ursache tiefer liegen kann, sieht es oft wie ein TCP- oder Anwendungsproblem aus. Merksatz: Teilweise funktionierende Verbindungen können auf MTU-Probleme hinweisen. --- **Werkzeuge für Schicht-4-Fehlersuche** Typische Werkzeuge und Informationen: | Werkzeug / Anzeige | Nutzen | |---|---| | Porttest | prüft TCP- oder UDP-Port | | netstat / ss | zeigt lauschende Dienste und Verbindungen | | Firewall-Logs | zeigt erlaubte oder blockierte Verbindungen | | Dienststatus | zeigt, ob Dienst läuft | | Packet Capture | zeigt SYN, ACK, RST, UDP-Anfragen | | NAT-Tabelle | zeigt Port-Zuordnungen | | Portscan | zeigt offene Ports, nur mit Berechtigung | | Anwendungslog | zeigt Fehler des Dienstes | Merksatz: Schicht 4 prüft man mit Porttests, Logs und Mitschnitten. --- **Porttest** Ein Porttest prüft, ob ein bestimmter TCP- oder UDP-Port erreichbar ist. Beispielhafte Prüffragen: Ist TCP 443 erreichbar? Ist TCP 22 erreichbar? Ist UDP 53 erreichbar? Antwortet der Dienst? Kommt ein Timeout? Kommt ein Reset? Wichtig: Ping ist kein Porttest. Merksatz: Porttest prüft Schicht 4, Ping prüft ICMP auf Schicht 3. --- **Lauschende Dienste prüfen** Auf einem Server sollte man prüfen: Lauscht der Dienst? Auf welchem Port lauscht er? Auf welcher IP-Adresse lauscht er? Nutzt er TCP oder UDP? Ist er nur lokal erreichbar? Ist der Dienst wirklich gestartet? Typische Zustände: LISTEN ESTABLISHED Merksatz: Dienst muss laufen und auf der richtigen Adresse lauschen. --- **Packet Capture bei TCP** In einem Mitschnitt kann man erkennen: - SYN - SYN-ACK - ACK - RST - FIN - Retransmissions - Timeouts - Quell-Port - Ziel-Port Typische Interpretation: SYN geht raus, keine Antwort: Filter, Routing oder Dienstproblem. SYN, SYN-ACK, ACK: Verbindung aufgebaut. RST: Verbindung wird zurückgesetzt. Merksatz: TCP-Mitschnitt zeigt den Verbindungsaufbau sehr gut. --- **Packet Capture bei UDP** Bei UDP sieht man keinen Handshake. Man prüft: - geht Anfrage raus? - ist Ziel-Port korrekt? - kommt Antwort zurück? - ist Quell-Port passend? - blockiert Firewall? - antwortet Dienst überhaupt? Beispiel DNS: Anfrage an UDP 53 Antwort von UDP 53 zurück Merksatz: Bei UDP vergleicht man Anfrage und Antwort. --- **Firewall-Logs prüfen** Firewall-Logs können zeigen: - Quelle - Ziel - Protokoll - Port - Aktion - Zeit - Regelname - Interface oder Zone Wichtige Fragen: Wird die Verbindung erlaubt? Wird sie blockiert? Welche Regel greift? Ist TCP oder UDP betroffen? Gibt es Rückverkehr? Merksatz: Firewall-Logs zeigen oft, ob Schicht 4 blockiert wird. --- **NAT- und Portweiterleitungsprüfung** Bei NAT oder Portweiterleitung prüft man: - externe IP korrekt? - kein CGNAT? - externer Port korrekt? - internes Ziel korrekt? - internes Ziel erreichbar? - TCP oder UDP korrekt? - Firewall erlaubt? - Dienst läuft? - Rückweg vorhanden? - Hairpin NAT nötig? Merksatz: NAT-Fehlersuche braucht Port, Protokoll, Ziel-IP und Rückweg. --- **Typische Prüf-Reihenfolge bei Dienstproblemen** Eine einfache Reihenfolge: 1. Ziel-IP erreichbar? 2. Route und Gateway korrekt? 3. richtiger Port? 4. richtiges Protokoll TCP oder UDP? 5. Dienst läuft? 6. Dienst lauscht auf richtiger IP? 7. lokale Server-Firewall erlaubt? 8. Netzwerk-Firewall erlaubt? 9. NAT oder Portweiterleitung korrekt? 10. Anwendung selbst prüfen Merksatz: Erst IP, dann Port, dann Dienst. --- **Beispiel: HTTPS intern nicht erreichbar** Fehlerbild: Client erreicht Server-IP per Ping. HTTPS auf TCP 443 funktioniert nicht. Prüfung: 1. Hört der Webserver auf TCP 443? 2. Ist TCP 443 auf der Server-Firewall erlaubt? 3. Ist Netzwerk-Firewall im Weg? 4. Nutzt der Dienst vielleicht TCP 8443? 5. Gibt es TLS- oder Anwendungsfehler? 6. Funktioniert Zugriff lokal auf dem Server? Merksatz: Ping geht, HTTPS nicht: TCP 443 und Dienst prüfen. --- **Beispiel: DNS antwortet nicht** Fehlerbild: Client kann externe IPs erreichen, aber Namen werden nicht aufgelöst. Prüfung: 1. DNS-Server-IP korrekt? 2. DNS-Server per IP erreichbar? 3. UDP 53 erlaubt? 4. TCP 53 bei Bedarf erlaubt? 5. DNS-Dienst läuft? 6. DNS-Zone korrekt? 7. Firewall-Logs prüfen. Merksatz: DNS-Fehler können Port- und Dienstfehler sein. --- **Beispiel: SSH von außen nicht erreichbar** Fehlerbild: SSH funktioniert intern, aber nicht von außen. Mögliche Ursachen: - Portweiterleitung fehlt - falscher externer Port - falsches Ziel intern - CGNAT - Firewall blockiert - SSH hört nur intern - Zugriff nur von bestimmten IPs erlaubt - Provider blockiert - DNS zeigt falsch Merksatz: Von außen braucht man öffentliche Erreichbarkeit, NAT-Regel, Firewall und laufenden Dienst. --- **Beispiel: UDP-VPN instabil** Fehlerbild: VPN verbindet manchmal, bricht aber ab oder bleibt instabil. Mögliche Ursachen: - UDP wird gefiltert - NAT-Zuordnung läuft ab - MTU-Problem - Paketverlust - Firewall-Zeitlimit - falscher Port - Provider filtert - asymmetrisches Routing Merksatz: UDP-VPN-Probleme können NAT-, Firewall- oder MTU-Ursachen haben. --- **Schicht 4 oder Schicht 7?** Nicht jedes Dienstproblem ist ein Portproblem. | Beobachtung | eher Ursache | |---|---| | TCP-Verbindung kommt nicht zustande | Schicht 4 / Firewall | | TCP 443 offen, aber Zertifikatsfehler | Schicht 6 / 7 | | TCP 443 offen, aber HTTP 500 | Anwendung | | DNS-Port erreichbar, aber falsche Antwort | DNS-Konfiguration | | SSH-Port offen, aber Login scheitert | Benutzer, Schlüssel, Rechte | | Datenbank-Port offen, aber Anmeldung scheitert | Anwendung / Rechte | Merksatz: Port erreichbar bedeutet nur: Transportweg zum Dienst ist möglich. --- **Schicht 4 oder Firewall?** Firewalls können auf Schicht 3 und 4 filtern. Typische Regelbestandteile: Quelle Ziel Protokoll Port Richtung Aktion Beispiel: Quelle: Mitarbeiter-Netz Ziel: Server-Netz Protokoll: TCP Port: 443 Aktion: erlauben Merksatz: Firewall-Regeln müssen Quelle, Ziel, Protokoll und Port passend erlauben. --- **Schicht 4 oder NAT?** Wenn ein Dienst intern funktioniert, aber extern nicht, ist NAT oder Portweiterleitung ein häufiger Prüfpunkte. Typische Unterscheidung: | Beobachtung | mögliche Ursache | |---|---| | intern geht, extern nicht | NAT, Firewall, CGNAT, DNS | | extern kommt falscher Dienst | falsche Portweiterleitung | | nur TCP geht, UDP nicht | falsches Protokoll freigegeben | | Rückverkehr fehlt | NAT oder Rückroute | | Test intern über Domain geht nicht | Hairpin NAT oder Split DNS | Merksatz: Externe Dienstprobleme oft mit NAT und Firewall prüfen. --- **Was Schicht-4-Fehlersuche nicht löst** Wenn TCP oder UDP korrekt funktioniert, können trotzdem Anwendungsfehler bestehen. Dann prüft man: - Anwendungskonfiguration - Benutzerrechte - Zertifikate - TLS-Version - Datenbankverbindung - Reverse Proxy - DNS-Inhalte - API-Endpunkte - Logs der Anwendung Merksatz: Schicht 4 transportiert, Schicht 7 verarbeitet. --- **Einordnung in das OSI-Modell** | Thema | Schicht | |---|---:| | Kabel und Link | 1 | | MAC und VLAN | 2 | | IP und Routing | 3 | | TCP und UDP | 4 | | Ports | 4 | | TCP-Handshake | 4 | | Firewall nach IP | 3 | | Firewall nach Port | 4 | | TLS-Zertifikat | 6 / 7 | | DNS-Dienst | 7 | | Webanwendung | 7 | Merksatz: Schicht 4 sagt: Kommt der Transport zum Dienst zustande? --- **Typische IHK-Fragen** In AP1 und AP2 kann zum Beispiel gefragt werden: - Was prüft man auf Schicht 4? - Warum reicht Ping nicht als Diensttest? - Was bedeutet offener Port? - Was bedeutet geschlossener Port? - Was bedeutet gefilterter Port? - Warum muss man TCP und UDP unterscheiden? - Warum kann TCP 443 blockiert sein, obwohl Ping funktioniert? - Was passiert beim TCP-Handshake? - Was bedeutet RST? - Was bedeutet Timeout? - Warum ist UDP-Fehlersuche schwieriger als TCP-Fehlersuche? - Welche Rolle spielen Firewall-Regeln bei Schicht 4? - Welche Rolle spielen NAT und Portweiterleitung? --- **Typische Prüfungsfallen** Ping prüft keine TCP- oder UDP-Ports. ICMP hat keine Ports. IP erreichbar heißt nicht: Dienst erreichbar. Port erreichbar heißt nicht: Anwendung korrekt. TCP und UDP sind getrennt zu betrachten. Gleiche Portnummer bei TCP und UDP ist nicht dasselbe. TCP-Handshake = SYN, SYN-ACK, ACK. Kein SYN-ACK kann Firewall-, Routing- oder Dienstproblem sein. RST bedeutet aktiver Abbruch. Timeout bedeutet keine rechtzeitige Antwort. UDP hat keinen Handshake. UDP-Fehler sind oft schwerer zu erkennen. Firewall-Regel braucht Protokoll und Port. Portweiterleitung braucht richtiges Protokoll. Dienst muss auf richtiger IP und richtigem Port lauschen. localhost ist nur lokal. --- **Wichtige Begriffe kurz erklärt** | Begriff | Kurze Erklärung | |---|---| | Schicht-4-Fehler | Fehler bei TCP, UDP oder Ports | | Porttest | Prüfung eines TCP- oder UDP-Ports | | offener Port | Dienst ist grundsätzlich erreichbar | | geschlossener Port | kein Dienst lauscht | | gefilterter Port | Firewall oder Filter blockiert | | TCP-Handshake | Verbindungsaufbau mit SYN, SYN-ACK, ACK | | SYN | TCP-Verbindungsanfrage | | SYN-ACK | Antwort und Bestätigung auf SYN | | ACK | Bestätigung | | RST | sofortiger TCP-Abbruch | | Timeout | Antwort kommt nicht rechtzeitig | | Retransmission | erneute Übertragung | | LISTEN | Dienst wartet auf Verbindung | | ESTABLISHED | Verbindung besteht | | localhost | eigenes Gerät, 127.0.0.1 | | Host-Firewall | Firewall direkt auf dem Server | | Portweiterleitung | externer Port wird intern weitergeleitet | | NAT-Tabelle | Zuordnung übersetzter Verbindungen | --- **IHK-sichere Kurzformulierung** Fehlersuche auf OSI-Schicht 4 bedeutet, TCP, UDP und Ports zu prüfen. Während Schicht 3 die IP-Erreichbarkeit eines Zielgeräts betrachtet, prüft Schicht 4, ob der gewünschte Dienst-Port erreichbar ist. Typische Schicht-4-Probleme sind geschlossene oder gefilterte Ports, fehlgeschlagene TCP-Handshakes, Timeouts, TCP-Resets, falsche TCP-/UDP-Freigaben, blockierende Firewalls oder fehlerhafte NAT- und Portweiterleitungen. Ein erfolgreicher Ping beweist nicht, dass ein TCP- oder UDP-Dienst erreichbar ist, und ein erreichbarer Port beweist nicht automatisch, dass die Anwendung korrekt funktioniert. --- **Merksätze** Schicht-4-Fehlersuche = TCP, UDP und Ports prüfen. IP erreichbar heißt nicht: Port erreichbar. Ping prüft ICMP, nicht TCP oder UDP. Porttest prüft Schicht 4. Dienstproblem = IP, Port, Protokoll, Firewall und Anwendung prüfen. TCP und UDP getrennt betrachten. Gleiche Portnummer bei TCP und UDP ist nicht dasselbe. TCP-Handshake = SYN, SYN-ACK, ACK. Kein Handshake = keine TCP-Verbindung. RST = aktiver Abbruch. Timeout = keine rechtzeitige Antwort. Offener Port = Dienst grundsätzlich erreichbar. Geschlossener Port = kein Dienst lauscht. Gefilterter Port = Firewall oder Filter im Weg. UDP hat keinen Handshake. UDP braucht Anfrage-Antwort-Prüfung. Firewall-Regel braucht Quelle, Ziel, Protokoll und Port. Portweiterleitung braucht richtige IP, richtigen Port und richtiges Protokoll. Dienst muss auf richtiger Schnittstelle lauschen. localhost ist nur lokal. Erst IP, dann Port, dann Dienst. # 7.5 Merksätze und Prüfungswissen zu OSI-Schicht 4 Diese Seite fasst die wichtigsten Inhalte zur OSI-Schicht 4 zusammen. OSI-Schicht 4 heißt: Transportschicht Die Hauptaufgabe von Schicht 4 ist: Daten zwischen Anwendungen auf Endgeräten transportieren. Dabei sind besonders wichtig: - TCP - UDP - Ports - Verbindungsaufbau - Zuverlässigkeit - Dienst-Erreichbarkeit - Firewall-Regeln nach Port - NAT/PAT mit Port-Zuordnung Merksatz: Schicht 4 = TCP, UDP und Ports. --- **Grundidee von Schicht 4** Schicht 3 bringt Daten zum richtigen Gerät. Schicht 4 bringt Daten zur richtigen Anwendung auf diesem Gerät. Beispiel: IP-Adresse: 192.168.10.50 Port: 443 Zusammen: 192.168.10.50:443 Das bedeutet: Gerät 192.168.10.50 Dienst auf Port 443 Merksatz: IP bringt zum Gerät. Port bringt zum Dienst. --- **Schicht 3 und Schicht 4 unterscheiden** | Frage | Schicht | |---|---:| | Welche IP-Adresse hat das Ziel? | 3 | | Gibt es eine Route zum Ziel? | 3 | | Ist das Gateway erreichbar? | 3 | | Funktioniert Ping auf die IP? | 3 | | Ist TCP 443 erreichbar? | 4 | | Ist UDP 53 erreichbar? | 4 | | Kommt der TCP-Handshake zustande? | 4 | | Läuft die Webanwendung korrekt? | 7 | Merksatz: IP-Erreichbarkeit = Schicht 3. Port-Erreichbarkeit = Schicht 4. --- **TCP** TCP steht für: Transmission Control Protocol TCP ist: verbindungsorientiert zuverlässig reihenfolgetreu bestätigungsbasiert TCP sorgt dafür, dass Daten vollständig und in richtiger Reihenfolge bei der Anwendung ankommen. Merksatz: TCP = zuverlässig und verbindungsorientiert. --- **UDP** UDP steht für: User Datagram Protocol UDP ist: verbindungslos schlank schnell ohne eingebaute Zustellgarantie UDP sendet Datagramme ohne vorherigen Verbindungsaufbau. Merksatz: UDP = schnell und verbindungslos. --- **TCP und UDP vergleichen** | Merkmal | TCP | UDP | |---|---|---| | Verbindungsaufbau | ja | nein | | Verbindung | verbindungsorientiert | verbindungslos | | Zustellgarantie | ja | nein | | Reihenfolge | wird sichergestellt | nicht sichergestellt | | Bestätigungen | ja | nein | | erneute Übertragung | ja | nein | | Overhead | höher | geringer | | Datenform | Segment | Datagramm | Merksatz: TCP kontrolliert. UDP sendet schlank. --- **Verbindungsorientiert** Verbindungsorientiert bedeutet: Vor der Datenübertragung wird eine Verbindung aufgebaut. TCP arbeitet verbindungsorientiert. Der Verbindungsaufbau erfolgt mit: SYN SYN-ACK ACK Merksatz: Verbindungsorientiert = Verbindung vor Datenübertragung. --- **Verbindungslos** Verbindungslos bedeutet: Es wird keine feste Verbindung aufgebaut. UDP sendet direkt ein Datagramm an Ziel-IP und Ziel-Port. UDP prüft nicht selbst: ob das Datagramm angekommen ist ob die Reihenfolge stimmt ob eine erneute Übertragung nötig ist Merksatz: Verbindungslos = senden ohne Handshake. --- **TCP-Drei-Wege-Handshake** Der TCP-Verbindungsaufbau besteht aus drei Schritten. | Schritt | Richtung | Bedeutung | |---:|---|---| | 1 | Client → Server | SYN | | 2 | Server → Client | SYN-ACK | | 3 | Client → Server | ACK | Nach dem dritten Schritt ist die TCP-Verbindung aufgebaut. Merksatz: TCP-Handshake = SYN, SYN-ACK, ACK. --- **SYN** SYN steht für: Synchronize SYN startet den TCP-Verbindungsaufbau. Vereinfacht sagt der Client: Ich möchte eine Verbindung aufbauen. Merksatz: SYN = Start der TCP-Verbindung. --- **SYN-ACK** SYN-ACK ist die Antwort des Servers auf das SYN. Der Server sagt vereinfacht: Ich habe deine Anfrage erhalten und bin bereit. Merksatz: SYN-ACK = Antwort und Bestätigung. --- **ACK** ACK steht für: Acknowledgement ACK bedeutet: Bestätigung Der Client bestätigt damit das SYN-ACK des Servers. Merksatz: ACK = Bestätigung. --- **TCP-Zuverlässigkeit** TCP bietet Zuverlässigkeit durch: - Sequenznummern - Bestätigungsnummern - ACKs - erneute Übertragung - Reihenfolgesicherung - Flusskontrolle - Staukontrolle Dadurch eignet sich TCP gut für Daten, die vollständig und korrekt ankommen müssen. Merksatz: TCP nutzt mehrere Mechanismen für zuverlässigen Transport. --- **Sequenznummern** Sequenznummern helfen TCP, Daten in die richtige Reihenfolge zu bringen. Sie zeigen: an welcher Stelle im Datenstrom ein Teil gehört. Damit kann TCP erkennen: Daten fehlen. Daten kamen doppelt. Daten kamen in falscher Reihenfolge. Merksatz: Sequenznummer = Position im TCP-Datenstrom. --- **Bestätigungen** TCP bestätigt empfangene Daten mit ACKs. Der Empfänger teilt dem Sender mit: welche Daten angekommen sind und welche Daten als Nächstes erwartet werden. Wenn eine Bestätigung fehlt, können Daten erneut gesendet werden. Merksatz: TCP bestätigt empfangene Daten. --- **Retransmission** Retransmission bedeutet: erneute Übertragung TCP sendet Daten erneut, wenn sie vermutlich verloren gegangen sind. Mögliche Ursachen: - Paketverlust - Timeout - beschädigte Daten - Überlastung - schlechte Verbindung Merksatz: Retransmission = TCP sendet erneut. --- **Flusskontrolle** Flusskontrolle schützt den Empfänger. Der Empfänger signalisiert, wie viele Daten er aufnehmen kann. Dadurch soll der Sender den Empfänger nicht überlasten. Merksatz: Flusskontrolle schützt den Empfänger. --- **Staukontrolle** Staukontrolle schützt das Netzwerk. TCP kann die Sendeleistung anpassen, wenn Paketverlust oder Überlastung erkannt wird. Ziel: Das Netzwerk soll nicht weiter überlastet werden. Merksatz: Staukontrolle schützt das Netzwerk. --- **TCP-Verbindungsabbau** TCP-Verbindungen können geordnet beendet werden. Wichtige Steuerbits: FIN ACK FIN bedeutet: Verbindung geordnet beenden. RST bedeutet: Verbindung sofort abbrechen. Merksatz: FIN beendet geordnet. RST bricht sofort ab. --- **TCP-Zustände** Wichtige TCP-Zustände: | Zustand | Bedeutung | |---|---| | LISTEN | Dienst wartet auf eingehende Verbindung | | SYN-SENT | Client hat SYN gesendet | | SYN-RECEIVED | Server hat SYN erhalten und SYN-ACK gesendet | | ESTABLISHED | Verbindung besteht | | FIN-WAIT | Verbindung wird beendet | | TIME-WAIT | Wartephase nach Verbindungsende | | CLOSED | Verbindung ist geschlossen | Merksatz: LISTEN = Dienst wartet. ESTABLISHED = Verbindung steht. --- **TCP-Segment** Die Datenform von TCP auf Schicht 4 heißt: Segment Ein TCP-Segment enthält unter anderem: - Quell-Port - Ziel-Port - Sequenznummer - Bestätigungsnummer - Steuerbits - Prüfsumme - Nutzdaten Merksatz: TCP arbeitet mit Segmenten. --- **UDP-Datagramm** Die Datenform von UDP auf Schicht 4 heißt: Datagramm Ein UDP-Datagramm enthält unter anderem: - Quell-Port - Ziel-Port - Länge - Prüfsumme - Nutzdaten Merksatz: UDP arbeitet mit Datagrammen. --- **Segment und Datagramm unterscheiden** | Protokoll | Datenform | |---|---| | TCP | Segment | | UDP | Datagramm | Prüfungsfalle: In der Umgangssprache sagt man oft „Paket“. Fachlich ist TCP auf Schicht 4 ein Segment. UDP auf Schicht 4 ist ein Datagramm. Merksatz: TCP = Segment. UDP = Datagramm. --- **Ports** Ein Port ist eine logische Dienstnummer auf Schicht 4. Ports unterscheiden Dienste auf einem Gerät. Beispiel: 192.168.10.50:22 192.168.10.50:80 192.168.10.50:443 Gleiche IP-Adresse, aber unterschiedliche Dienste. Merksatz: Port = Dienstnummer. --- **Port ist nicht gleich Switch-Port** | Begriff | Bedeutung | Schicht | |---|---|---:| | Switch-Port | physischer Anschluss | 1 / 2 | | TCP-Port | logische Dienstnummer | 4 | | UDP-Port | logische Dienstnummer | 4 | Merksatz: Switch-Port = physisch. TCP-/UDP-Port = logisch. --- **Portnummern** Portnummern gehen von: 0 bis: 65535 Grund: Ports sind 16 Bit groß. 16 Bit ermöglichen: 65536 Werte Merksatz: Portnummern = 0 bis 65535. --- **Portbereiche** | Bereich | Portnummern | Bedeutung | |---|---:|---| | Well-Known Ports | 0 – 1023 | bekannte Standarddienste | | Registered Ports | 1024 – 49151 | registrierte Anwendungsports | | Dynamic / Ephemeral Ports | 49152 – 65535 | temporäre Client-Ports | Merksatz: Well-Known = bekannt. Ephemeral = temporär. --- **Quell-Port und Ziel-Port** Ein TCP- oder UDP-Header enthält: Quell-Port Ziel-Port Beispiel HTTPS: Client: 192.168.10.20:52344 Server: 93.184.216.34:443 Dabei gilt: Ziel-Port 443 = HTTPS-Dienst Quell-Port 52344 = temporärer Client-Port Merksatz: Ziel-Port zeigt den Dienst. Quell-Port hilft bei der Rückzuordnung. --- **Socket** Ein Socket besteht aus: IP-Adresse und Port Beispiel: 192.168.10.20:52344 Eine TCP-Verbindung wird eindeutig durch folgende Kombination: Quell-IP Quell-Port Ziel-IP Ziel-Port Protokoll Merksatz: Socket = IP-Adresse plus Port. --- **TCP-Port und UDP-Port getrennt betrachten** Die gleiche Portnummer kann bei TCP und UDP getrennt existieren. Beispiel: TCP 53 UDP 53 Beide können DNS betreffen, sind aber technisch unterschiedliche Transportwege. Eine Firewall-Regel für TCP 53 erlaubt nicht automatisch UDP 53. Merksatz: Portnummer immer mit TCP oder UDP nennen. --- **Wichtige Standardports** | Dienst | Protokoll | Port | |---|---|---:| | FTP Steuerverbindung | TCP | 21 | | SSH | TCP | 22 | | Telnet | TCP | 23 | | SMTP | TCP | 25 | | DNS | TCP / UDP | 53 | | DHCP Server | UDP | 67 | | DHCP Client | UDP | 68 | | HTTP | TCP | 80 | | POP3 | TCP | 110 | | NTP | UDP | 123 | | IMAP | TCP | 143 | | HTTPS | TCP | 443 | | IMAPS | TCP | 993 | | POP3S | TCP | 995 | | RDP | TCP | 3389 | Merksatz: HTTP 80, HTTPS 443, SSH 22, DNS 53, DHCP 67/68. --- **DNS** DNS nutzt häufig: UDP 53 DNS kann aber auch nutzen: TCP 53 Beispiele für TCP bei DNS: - große Antworten - Zonentransfers - bestimmte DNSSEC-Fälle Merksatz: DNS = UDP 53 häufig, TCP 53 ebenfalls möglich. --- **DHCP** DHCP nutzt UDP. Wichtige Ports: | Rolle | Protokoll | Port | |---|---|---:| | DHCP-Server | UDP | 67 | | DHCP-Client | UDP | 68 | Merksatz: DHCP = UDP 67 und 68. --- **HTTP und HTTPS** HTTP nutzt typischerweise: TCP 80 HTTPS nutzt typischerweise: TCP 443 HTTPS nutzt zusätzlich TLS für Verschlüsselung. Merksatz: HTTP = TCP 80. HTTPS = TCP 443. --- **SSH und Telnet** SSH nutzt: TCP 22 Telnet nutzt: TCP 23 Wichtiger Unterschied: SSH ist verschlüsselt. Telnet ist unverschlüsselt. Merksatz: SSH statt Telnet verwenden. --- **E-Mail-Protokolle** | Protokoll | Zweck | typischer Port | |---|---|---:| | SMTP | E-Mail senden / transportieren | TCP 25 | | POP3 | E-Mail abrufen | TCP 110 | | IMAP | E-Mail abrufen und verwalten | TCP 143 | | IMAPS | IMAP verschlüsselt | TCP 993 | | POP3S | POP3 verschlüsselt | TCP 995 | Merksatz: SMTP sendet. POP3 und IMAP holen ab. --- **NTP** NTP steht für: Network Time Protocol Typischer Port: UDP 123 NTP dient der Zeitsynchronisation. Wichtig für: - Zertifikate - Kerberos - Logs - Monitoring - Fehlersuche Merksatz: NTP = UDP 123. --- **RDP** RDP steht für: Remote Desktop Protocol Typischer Port: TCP 3389 RDP dient dem grafischen Fernzugriff auf Windows-Systeme. Wichtig: RDP nicht ungeschützt direkt ins Internet öffnen. Merksatz: RDP = TCP 3389, sorgfältig absichern. --- **Portstatus** Ein Port kann aus Sicht eines Clients unterschiedlich wirken. | Status | Bedeutung | |---|---| | offen | Dienst nimmt Verbindung an oder antwortet | | geschlossen | kein Dienst lauscht auf diesem Port | | gefiltert | Firewall oder Paketfilter blockiert | | offen, aber Anwendung fehlerhaft | Schicht 4 erreichbar, höhere Schicht fehlerhaft | Merksatz: Portstatus hilft bei der Eingrenzung. --- **Offener Port** Ein offener Port bedeutet: Ein Dienst ist grundsätzlich erreichbar. Aber ein offener Port beweist nicht: dass die Anwendung korrekt funktioniert dass Login klappt dass Zertifikate stimmen dass keine Fehler in der Anwendung bestehen Merksatz: Offener Port = Transport zum Dienst möglich. --- **Geschlossener Port** Ein geschlossener Port bedeutet: Kein Dienst lauscht auf diesem Port. Der Host kann trotzdem erreichbar sein. Beispiel: Ping funktioniert. TCP 22 geschlossen. Dann ist der Host erreichbar, aber SSH läuft dort nicht oder nicht auf Port 22. Merksatz: Geschlossener Port heißt nicht: Gerät offline. --- **Gefilterter Port** Ein gefilterter Port bedeutet häufig: Firewall oder Paketfilter blockiert. Typisches Verhalten: Timeout keine klare Antwort Verbindung hängt Merksatz: Gefiltert = oft Firewall im Weg. --- **Firewall-Regeln auf Schicht 4** Firewalls nutzen häufig Ports. Eine vollständige Regel enthält idealerweise: - Quelle - Ziel - Protokoll - Port - Richtung - Aktion - Kommentar oder Zweck Beispiel: Quelle: Mitarbeiter-Netz Ziel: Internet Protokoll: TCP Port: 443 Aktion: erlauben Merksatz: Firewall-Regel = Quelle, Ziel, Protokoll, Port, Aktion. --- **Portweiterleitung** Portweiterleitung bedeutet: Ein externer Port wird an ein internes Ziel weitergeleitet. Beispiel: öffentlich: 93.184.100.10:443 intern: 192.168.10.50:443 Wichtig: Protokoll muss stimmen. Ziel-IP muss stimmen. Dienst muss laufen. Firewall muss erlauben. Merksatz: Portweiterleitung braucht richtige IP, richtigen Port, richtiges Protokoll und laufenden Dienst. --- **NAT/PAT und Ports** PAT nutzt Ports, um Verbindungen zu unterscheiden. Beispiel: | Intern | Extern | |---|---| | 192.168.10.20:52344 | 93.184.100.10:40001 | | 192.168.10.30:52344 | 93.184.100.10:40002 | Dadurch können mehrere interne Geräte dieselbe öffentliche IP-Adresse nutzen. Merksatz: PAT unterscheidet Verbindungen über Ports. --- **TCP und UDP bei NAT/PAT** Bei TCP kann ein NAT-Gerät Verbindungszustände gut verfolgen. Bei UDP gibt es keinen echten Verbindungsaufbau. Deshalb arbeitet NAT bei UDP häufig mit Zeitfenstern und Zuordnungstabellen. Wenn eine Zuordnung abläuft, können Antworten verloren gehen. Merksatz: NAT verfolgt TCP leichter als UDP. --- **Ping und Porttest unterscheiden** Ping nutzt ICMP. ICMP nutzt keine TCP- oder UDP-Ports. Deshalb gilt: Ping prüft IP-Erreichbarkeit, aber keinen Dienst-Port. Beispiel: Ping funktioniert. Das beweist nicht: TCP 443 ist offen. Merksatz: Ping prüft Schicht 3. Porttest prüft Schicht 4. --- **Typische Schicht-4-Fehler** Typische Fehler sind: - falscher Port - falsches Protokoll TCP oder UDP - Dienst läuft nicht - Dienst lauscht auf falscher IP - Dienst lauscht nur auf localhost - Firewall blockiert - TCP-Handshake scheitert - RST - Timeout - Portweiterleitung falsch - NAT/PAT-Zuordnung fehlt - Rückweg fehlt - UDP-Antwort kommt nicht zurück Merksatz: Schicht-4-Fehler betreffen Transport zum Dienst. --- **Fehlerbild: Ping geht, Dienst nicht** Beispiel: ping server funktioniert. HTTPS funktioniert nicht. Mögliche Ursachen: - TCP 443 geschlossen - Firewall blockiert TCP 443 - Webserver läuft nicht - Webserver hört auf anderem Port - TLS- oder Anwendungsproblem - Reverse Proxy falsch Merksatz: Ping geht, Dienst nicht: Schicht 4 und 7 prüfen. --- **Fehlerbild: TCP-Handshake scheitert** Der TCP-Handshake lautet: SYN SYN-ACK ACK Wenn der Handshake nicht vollständig ist, entsteht keine TCP-Verbindung. Mögliche Ursachen: - Dienst lauscht nicht - Firewall blockiert - Rückroute fehlt - NAT falsch - Server lehnt ab - Netzwerkverlust Merksatz: Kein vollständiger Handshake = keine TCP-Verbindung. --- **Fehlerbild: RST** RST bedeutet: Reset Ein RST bricht eine TCP-Verbindung sofort ab. Mögliche Ursachen: - Port geschlossen - Dienst lehnt Verbindung ab - Firewall sendet Reset - Anwendung bricht ab - falsches Protokoll Merksatz: RST = aktiver TCP-Abbruch. --- **Fehlerbild: Timeout** Timeout bedeutet: Eine erwartete Antwort kommt nicht rechtzeitig. Mögliche Ursachen: - Firewall verwirft still - Server antwortet nicht - Rückweg fehlt - NAT-Zuordnung fehlt - falsches Ziel - Paketverlust Merksatz: Timeout = keine rechtzeitige Antwort. --- **Fehlerbild: UDP antwortet nicht** UDP hat keinen Handshake. Wenn keine Antwort kommt, kann das bedeuten: - Dienst läuft nicht - UDP-Port falsch - Firewall blockiert - Anfrage ungültig - Antwortweg fehlt - NAT-Zuordnung abgelaufen - Paketverlust Merksatz: UDP braucht Anfrage-Antwort-Prüfung. --- **Schicht 4 oder Schicht 7?** | Beobachtung | eher Ursache | |---|---| | TCP-Verbindung kommt nicht zustande | Schicht 4 / Firewall | | TCP-Port offen, aber Login scheitert | Anwendung / Authentifizierung | | TCP 443 offen, aber Zertifikatsfehler | Darstellung / Anwendung | | DNS-Port erreichbar, aber falsche Antwort | DNS-Konfiguration | | Webserver antwortet mit Fehler 500 | Anwendung | | SSH-Port offen, aber Schlüssel abgelehnt | Benutzer / Schlüssel / Rechte | Merksatz: Port erreichbar bedeutet: Transport ist möglich, Anwendung muss trotzdem geprüft werden. --- **Was Schicht 4 nicht macht** Schicht 4 macht nicht: - IP-Adressen vergeben - Routing zwischen Netzen durchführen - MAC-Adressen auflösen - DNS-Namen auflösen - Webseiten bereitstellen - Benutzer authentifizieren - Zertifikate prüfen - Inhalte interpretieren - Dateirechte verwalten Merksatz: Schicht 4 transportiert, interpretiert aber keine Anwendung. --- **Prüfungswissen: wichtigste Zuordnungen** | Begriff | richtige Einordnung | |---|---| | TCP | Schicht 4 | | UDP | Schicht 4 | | Port | Schicht 4 | | TCP-Handshake | Schicht 4 | | Segment | TCP auf Schicht 4 | | Datagramm | UDP auf Schicht 4 | | Socket | Schicht 4 mit IP-Bezug | | ICMP | Schicht 3 | | IP-Adresse | Schicht 3 | | Routing | Schicht 3 | | DNS | Schicht 7, nutzt TCP/UDP 53 | | HTTP | Schicht 7, nutzt TCP 80 | | HTTPS | Schicht 7, nutzt TCP 443 | | DHCP | Schicht 7, nutzt UDP 67/68 | Merksatz: TCP, UDP und Ports = Schicht 4. --- **Typische IHK-Fragen** In AP1 und AP2 kann zum Beispiel gefragt werden: - Welche Aufgabe hat die Transportschicht? - Was ist TCP? - Was ist UDP? - Was ist der Unterschied zwischen TCP und UDP? - Was bedeutet verbindungsorientiert? - Was bedeutet verbindungslos? - Wie funktioniert der TCP-Drei-Wege-Handshake? - Was ist ein Port? - Warum braucht man Ports? - Was ist ein Socket? - Welche Portbereiche gibt es? - Welche Standardports sollte man kennen? - Warum nutzt DNS TCP und UDP? - Warum nutzt DHCP UDP? - Warum reicht Ping nicht als Diensttest? - Was bedeutet offener, geschlossener oder gefilterter Port? - Warum muss eine Firewall TCP und UDP unterscheiden? --- **Typische Prüfungsfallen** TCP gehört zu Schicht 4. UDP gehört zu Schicht 4. Ports gehören zu Schicht 4. ICMP nutzt keine Ports. Ping ist kein Porttest. TCP ist verbindungsorientiert. UDP ist verbindungslos. TCP-Handshake = SYN, SYN-ACK, ACK. TCP nutzt Segmente. UDP nutzt Datagramme. TCP-Port und UDP-Port sind getrennt. Gleiche Portnummer bedeutet nicht gleiches Protokoll. DNS nutzt UDP 53 und TCP 53. DHCP nutzt UDP 67 und 68. HTTP nutzt TCP 80. HTTPS nutzt TCP 443. SSH nutzt TCP 22. RDP nutzt TCP 3389. Offener Port heißt nicht automatisch: Anwendung funktioniert. Geschlossener Port heißt nicht: Gerät offline. Gefilterter Port heißt oft: Firewall im Weg. --- **Wichtige Begriffe kurz erklärt** | Begriff | Kurze Erklärung | |---|---| | Transportschicht | OSI-Schicht 4 | | TCP | zuverlässiges, verbindungsorientiertes Transportprotokoll | | UDP | verbindungsloses Transportprotokoll | | Port | logische Dienstnummer | | TCP-Port | Dienstnummer für TCP | | UDP-Port | Dienstnummer für UDP | | Socket | IP-Adresse plus Port | | Segment | TCP-Dateneinheit | | Datagramm | UDP-Dateneinheit | | SYN | Start des TCP-Verbindungsaufbaus | | SYN-ACK | Antwort und Bestätigung auf SYN | | ACK | Bestätigung | | RST | sofortiger TCP-Abbruch | | FIN | geordneter TCP-Abbau | | Timeout | Antwort bleibt zu lange aus | | Retransmission | erneute Übertragung | | LISTEN | Dienst wartet auf Verbindung | | ESTABLISHED | Verbindung besteht | | Well-Known Port | Port 0 bis 1023 | | Ephemeral Port | temporärer Client-Port | | Portweiterleitung | externer Port wird intern weitergeleitet | | gefilterter Port | Firewall oder Paketfilter blockiert | --- **IHK-sichere Gesamtformulierung** Die Transportschicht ist Schicht 4 des OSI-Modells. Sie sorgt für den Transport von Daten zwischen Anwendungen auf Endgeräten. Dafür werden vor allem TCP, UDP und Ports verwendet. TCP ist verbindungsorientiert und zuverlässig, baut eine Verbindung über SYN, SYN-ACK und ACK auf und nutzt Bestätigungen, Sequenznummern und erneute Übertragung. UDP ist verbindungslos, schlanker und bietet keine eingebaute Zustellgarantie. Ports dienen dazu, Dienste auf einem Gerät zu unterscheiden. Eine IP-Adresse zeigt zum Gerät, der Port zeigt zum Dienst. TCP- und UDP-Ports sind getrennt zu betrachten. --- **Wichtigste Merksätze** Schicht 4 = Transportschicht. Schicht 4 = TCP, UDP und Ports. IP bringt zum Gerät. Port bringt zum Dienst. Port = logische Dienstnummer. Switch-Port ist physisch. TCP-Port ist logisch. TCP = verbindungsorientiert. UDP = verbindungslos. TCP = zuverlässig. UDP = schlank und schnell. TCP-Handshake = SYN, SYN-ACK, ACK. TCP nutzt ACKs. TCP nutzt Sequenznummern. TCP kann erneut übertragen. TCP stellt Reihenfolge sicher. UDP hat keinen Handshake. UDP bietet keine eingebaute Zustellgarantie. TCP = Segment. UDP = Datagramm. Portnummern gehen von 0 bis 65535. Well-Known Ports = 0 bis 1023. Ephemeral Ports = temporäre Client-Ports. Ziel-Port zeigt den Dienst. Quell-Port hilft bei der Rückzuordnung. Socket = IP-Adresse plus Port. HTTP = TCP 80. HTTPS = TCP 443. SSH = TCP 22. DNS = UDP 53 und TCP 53. DHCP = UDP 67 und 68. NTP = UDP 123. RDP = TCP 3389. Ping nutzt ICMP, nicht TCP oder UDP. Ping ist kein Porttest. IP erreichbar = Schicht 3. Port erreichbar = Schicht 4. Anwendung korrekt = höhere Schicht. Offener Port heißt nicht automatisch sicher. Firewall-Regel braucht Quelle, Ziel, Protokoll und Port. Portweiterleitung braucht richtige IP, richtigen Port und richtiges Protokoll.