---
# System prepended metadata

title: ═══════════════════════════════════════════════════════════════

---

# ═══════════════════════════════════════════════════════════════
# RECHNERNETZE – KLAUSUR-MERKZETTEL (Prof. Graffi, HS RheinMain WS2025)
# ═══════════════════════════════════════════════════════════════

## 1. OSI 7-SCHICHTEN-MODELL
```
| Nr | Schicht       | Aufgabe                              | Protokolle/Bsp        | Adressierung   | Dateneinheit| Geräte          |
|----|---------------|--------------------------------------|-----------------------|----------------|-------------|-----------------|
| 7  | Application   | Anwendungskommunikation              | HTTP,DNS,SMTP,FTP,DHCP| –              | APDU        | –               |
| 6  | Presentation  | Kodierung, Kompression, Verschl.     | SSL(alt), JPEG, ASCII | –              | PPDU        | –               |
| 5  | Session       | Sitzungsverwaltung, Dialoge          | NetBIOS, RPC          | –              | SPDU        | –               |
| 4  | Transport     | Ende-zu-Ende, Prozess-zu-Prozess     | TCP, UDP              | **Port-Nr**    | Segment/TPDU| –               |
| 3  | Network       | Routing, Wegewahl, log. Adressierung | IP, ICMP, OSPF, BGP   | **IP-Adresse** | Packet      | **Router**      |
| 2  | Data Link     | 1-Hop-Zustellung, Medienzugriff      | Ethernet, 802.11, PPP | **MAC-Adresse**| Frame       |**Switch/Bridge**|
| 1  | Physical      | Bitübertragung auf Medium            | Kabel, Funk, Glasfaser| –              | Bit         | **Hub/Repeater**|

- **Kapselung:** App-Daten → +TCP-Header → +IP-Header → +Ethernet-Header+Trailer → Bits
- **TCP/IP-Stack (4 Schichten):** Application → Transport → Internet → Network Access
- **Router:** Entpackt bis Schicht 3 (IP), leitet weiter, verpackt neu (neue Schicht 2 Header!)
- **Switch:** Entpackt bis Schicht 2 (MAC), leitet weiter basierend auf MAC-Tabelle
```
## 2. LEITUNGS- vs. PAKETVERMITTLUNG
```
Leitungsvermittlung (z.B. Telefonnetz/ISDN):
  - Dedizierte Leitung wird vor Kommunikation Ende-zu-Ende reserviert
  - Bandbreite + Latenz garantiert, aber verschwendet wenn nicht genutzt
  - Feste Nutzeranzahl (z.B. 1Gbit/s, 100Mbit/User → max 10 User)
  - Aufteilung: FDM (jeder eigene Frequenz) oder TDM (jeder Zeitschlitze)

Paketvermittlung (z.B. Internet/IP):
  - Daten in Pakete zerlegt, teilen sich Ressourcen (statist. Multiplexing)
  - Keine Bandbreite-/Latenzgarantie, aber VIEL bessere Auslastung
  - Mehr Nutzer möglich (35 statt 10 bei 10% Aktivität, P(Überlast)<0.04%)
  - Store and Forward: Router empfängt ganzes Paket bevor er weiterleitet
  - Probleme: Warteschlangen, Paketverlust, Umordnung, Überlast
```
## 3. KENNZAHLEN & FORMELN
```
Gesamtverzögerung = d_proc + d_queue + d_trans + d_prop

d_proc  = Verarbeitungsverzögerung (Header prüfen, Routing, ~µs)
d_queue = Warteschlangenverzögerung (warten auf Leitung, variabel)
d_trans = L / R   (Übertragungsverzögerung: Paketlänge L [Bit] / Bitrate R [Bit/s])
d_prop  = d / s   (Ausbreitungsverzögerung: Distanz d [m] / Lichtgeschw. s [~2·10⁸ m/s])

Durchsatz = min(R_Server, R_Client, alle R_Links auf dem Pfad)   → Flaschenhals!
Auslastung ρ = L·a / R    (a = Paketankunftsrate [Pakete/s])
    ρ → 1: Verzögerung → ∞  |  ρ > 1: Paketverlust!
RTT = Round Trip Time (Hin + Rück)
Bandbreite-Verzögerungs-Produkt = R × d_prop  (Bits "unterwegs")
```

## 4. IPv4 ADRESSIERUNG & SUBNETTING

```IPv4: 32 Bit = 4 Bytes, Punkt-Dezimal (z.B. 192.168.1.1)

Klassen: A=1-127(8+24) B=128-191(16+16) C=192-223(24+8) D=224-239(MC) E=240+(res.)
Private: 10.0.0.0/8 | 172.16.0.0/12 | 192.168.0.0/16

══ NETZMASKE-TABELLE (auswendig!) ══
  128=1  192=2  224=3  240=4  248=5  252=6  254=7  255=8  0=0
  (Dezimalwert = Anzahl Einsen in dem Byte)

══ Dezimal → Binär: Stellenwerte ══
  128  64  32  16 | 8  4  2  1
  Bsp: 192=128+64=11000000  172=128+32+8+4=10101100  23=16+4+2+1=00010111

══ REZEPTE ══

Netzmaske→CIDR:  Einsen pro Byte zählen (Tabelle!), addieren
  255.255.128.0 → 8+8+1+0 = /17  |  255.255.255.192 → 8+8+8+2 = /26

CIDR→Netzmaske: /n Einsen, Rest Nullen, je 8 Bit → Dezimal
  /20 → 11111111.11111111.11110000.00000000 → 255.255.240.0

Netz/Host-Teil:  IP binär schreiben, Strich nach n-tem Bit
  172.30.24.23/17 → 10101100.00011110.0|0011000.00010111
                    ←── Netzteil 17 ──→|←── Host 15 ──→

Netzadresse:     Hostbits (rechts vom Strich) alle auf 0
  → 10101100.00011110.0|0000000.00000000 = 172.30.0.0

Broadcast:       Hostbits alle auf 1
  → 10101100.00011110.0|1111111.11111111 = 172.30.127.255

Hosts:           2^(32-n) - 2
  /17→2^15-2=32766  /24→2^8-2=254  /26→2^6-2=62

Subnetz-Test:    IP L_AND Maske == Netzadresse? → gehört dazu
Longest Prefix:  Mehrere Treffer → längster (spezifischster) gewinnt

Netz aufteilen:  Größtes Subnetz zuerst! Hosts→nächste 2er-Potenz→CIDR
  1500 Hosts→2^11=2048→/21 | 700 Hosts→2^10=1024→/22
  Nacheinander vergeben: 10.0.240.0/21 + 10.0.248.0/22 + 10.0.252.0/22
```
## 5. IP-HEADER, FRAGMENTIERUNG, IPv6
```
IPv4-Header (20 Bytes min):
  Version(4)|IHL(4)|ToS(8)|Total Length(16)
  Identification(16)|Flags(3)|Fragment Offset(13)
  TTL(8)|Protocol(8)|Header Checksum(16)
  Source IP(32)|Destination IP(32)|[Options]

TTL: -1 pro Hop, bei 0 → verworfen + ICMP "Time Exceeded"
Protocol: 6=TCP, 17=UDP, 1=ICMP
Flags: DF (Don't Fragment), MF (More Fragments)
Fragment Offset = Byte-Position / 8

IPv6: 128 Bit, kein Fragmentieren im Router (nur Endhost!)
  Tunnelbau: IPv6 in IPv4 kapseln (Src/Dst = Tunnelendpunkte)
  Kein Header-Checksum, kein Options-Feld → einfacher/schneller
  
══ Ergänzung zu #5: ICMP ══
ICMP: Fehlermeldungen + Diagnose auf Schicht 3 (kein Port, kein TCP/UDP)
  Ping = ICMP Echo Request/Reply → RTT messen
  Traceroute = TTL schrittweise erhöhen → ICMP Time Exceeded pro Hop
  Weitere: Destination Unreachable, Redirect
```

## 6. NAT & DHCP
```
NAT (Network Address Translation):
  Private IP:Port ←→ Öffentliche IP:Port (NAT-Tabelle im Router)
  Alle ausgehenden Pakete: gleiche öffentliche IP, verschiedene Ports
  Eingehend: Port bestimmt internen Host → kein Mapping = verworfen!
  → "Zufällig" sicherheitsfördernd (Paketfilter-Effekt)

DHCP (Dynamic Host Configuration Protocol):
  Automatische IP-Vergabe, UDP (Client Port 68, Server Port 67)
  DORA: Discover → Offer → Request → ACK
  Client startet mit 0.0.0.0 und sendet Broadcast an 255.255.255.255
  Server bietet IP, Subnetzmaske, Gateway, DNS-Server an
```

## 7. TCP
```
Eigenschaften: verbindungsorientiert, zuverlässig, Vollduplex, Bytestream
Ports: 0-1023 Well-Known, 1024-65535 frei
Socket = (Src-IP, Src-Port, Dst-IP, Dst-Port)

Header (20B min): SrcPort|DstPort|SeqNr(Bytes!)|ACKnr(nächstes erw. Byte, kumulativ)
  DataOff|Flags(C,E,U,A,P,R,S,F)|Window|Checksum|UrgPtr|[Options]
  SYN=Aufbau ACK=Bestätigung FIN=Abbau RST=Reset PSH=Push URG=Urgent

3-Way-Handshake:                          Bsp (InitSeq A=42, B=3141):
  1) C→S: SYN,    Seq=x         SYNSENT     A→B: SYN, Seq=42
  2) S→C: SYN+ACK,Seq=y,ACK=x+1 SYN RCVD   B→A: SYN+ACK, Seq=3141, ACK=43
  3) C→S: ACK,    Seq=x+1,ACK=y+1 ESTAB    A→B: ACK, Seq=43, ACK=3142
Abbau: FIN→ACK→FIN→ACK (4-Way, TIME_WAIT beim Initiator)

Daten nach Handshake (Seq zählt Bytes!):
  A sendet 500B: Seq=x+1, Len=500 → B: ACK=x+501
  A sendet 300B: Seq=x+501, Len=300 → B: ACK=x+801
  Regel: ACK = Seq + Datenlänge = nächstes erwartetes Byte

Flusskontrolle: RWND = freier Empfangspuffer, in jedem ACK mitgeteilt
  Sender darf max RWND Bytes unbestätigt "in flight" haben (Sliding Window)
Staukontrolle (AIMD): CWND = geschätzte Netzkapazität, Senderate=min(CWND,RWND)
  Slow Start:       CWND ×2 pro RTT (exponent.) bis ssthresh
  Cong. Avoidance:  CWND +1 MSS pro RTT (linear) ab ssthresh
  3 Dup-ACKs (Reno):  ssthresh=CWND/2, CWND=ssthresh → Fast Retransmit
  Timeout (Tahoe):     ssthresh=CWND/2, CWND=1 MSS   → Slow Start (drastisch!)

CWND-Graph ablesen:
  Exponentiell (1→2→4→8) = Slow Start | Linear (+1/RTT) = Cong. Avoidance
  CWND halbiert, bleibt hoch = 3 Dup-ACKs | CWND→1 = Timeout
  ssthresh ändert sich NUR bei Verlust: neuer ssthresh = CWND_vor_Verlust/2

TCP vs UDP:
  Nur TCP: SeqNr, Überlast-/Flusskontrolle, Fairness, verbindungsor., zuverlässig
  Nur UDP: verbindungslos
  Beide:   Multiplexing, Prüfsumme, Transportschicht
  Keins:   Sicherungsschicht (!)
```
## 8. UDP (User Datagram Protocol)
```
Verbindungslos, unzuverlässig, schnell, kein Handshake
Header (8 Bytes): Src Port(16)|Dst Port(16)|Length(16)|Checksum(16)
Kein: Seq-Nr, ACK, RWND, CWND, Flusskontrolle, Überlastkontrolle
Nutzen: DNS(53), DHCP(67/68), NTP, RIP, Streaming, VoIP, Gaming

══ INTERNET CHECKSUM (TCP/UDP/IP) ══
1. 16-Bit-Blöcke summieren, bei Übertrag: Wraparound addieren (+0001)
2. Einerkomplement von Summe(Bits flippen) = Prüfsumme
Empfänger: alle Blöcke + Prüfsumme = 1111...1? → OK, sonst Fehler
```

## 9. ROUTING
```
Routingtabelle: (Zielnetz/Maske, Next-Hop/Interface)
AS = Autonomes System | IGP = innerhalb AS (RIP,OSPF) | EGP = zwischen AS (BGP)

══ LINK STATE (OSPF) – Dijkstra ══
Jeder Router kennt GESAMTE Topologie (Flooding)
Dijkstra: N'=besucht, D(v)=Kosten zu v, p(v)=Vorgänger
  1. N'={Start}, D(Nachbarn)=direkte Kosten, D(Rest)=∞
  2. Nimm w∉N' mit kleinstem D(w), füge zu N' hinzu
  3. Für Nachbarn v von w: D(v)=min(D(v), D(w)+c(w,v)), merke p(v)
  4. Wiederhole bis alle in N'
  Bsp (Start B):  N'    |D(A),p|D(C),p|D(D),p|D(E),p|D(F),p
                  B     |2,B   |∞     |∞     |4,B   |∞
                  B,A   |      |3,A   |∞     |4,B   |∞
                  B,A,C |      |      |6,C   |4,B   |∞  ...
OSPF: IGP, Bandbreite als Metrik, Areas (Area 0=Backbone)

══ DISTANCE VECTOR (RIP) – Bellman-Ford ══
Nur Nachbarn bekannt, KEIN globales Wissen
  D(x,y) = min über Nachbarn v { c(x,v) + D(v,y) }
  Periodischer Austausch der DV-Tabellen, bei Änderung neu berechnen
Probleme: Count-to-Infinity, Routing-Loops
Lösungen: Split Horizon, Poison Reverse, Hold-Down Timer
RIP: Hop-Count max 15 (16=∞), Updates 30s, UDP 520

BGP: EGP, Path Vector, TCP 179, Policy-basiert (nicht kürzester Weg!)
```

## 10. ETHERNET & SICHERUNGSSCHICHT (Schicht 2)
```
MAC: 48 Bit (6B), z.B. AA:BB:CC:DD:EE:FF, Broadcast=FF:FF:FF:FF:FF:FF
  Erste 3B = Hersteller (OUI), letzte 3B = Geräte-ID

Frame: Preamble(7)|SFD(1)|DstMAC(6)|SrcMAC(6)|Type(2)|Data(46-1500)|FCS(4)
  FCS=CRC-32, min 64B, max 1518B (mit VLAN-Tag: 1522B)

CSMA/CD: 1.Höre ob frei → 2.Sende → 3.Kollision? Abbruch+JAM
  Backoff: warte 0..2^n-1 × Slotzeit (n=Kollisionszähler, max 10)
  Nur Halbduplex! Vollduplex = keine Kollisionen

ARP: IP → MAC auflösen
  Request=Broadcast("Wer hat IP x?") → Reply=Unicast("Meine MAC ist...")
  Cache mit TTL ~20min
  ARP-Spoofing: falsche Replies → Man-in-the-Middle!
  
══ Ergänzung zu #10: CRC (Ethernet, WiFi) ══
Stärker als Checksum! Erkennt alle Burstfehler < r+1 Bit
D=Datenbits, G=Generator (r+1 Bit), gesucht: r CRC-Bits R
  R = Rest von (D · 2^r) ÷ G  (XOR-Division/Polynomdivision)
  Sende <D,R>, Empfänger teilt <D,R> durch G → Rest=0? OK
```

## 11. SWITCHES, STP, VLANs
```
Switch (Schicht 2): selbstlernend, transparent, jeder Port=eigene Kollisionsdomäne
  MAC-Tabelle: lernt Src-MAC→Port | Bekannt→weiterleiten | Unbekannt→Flooding
Hub (Schicht 1): alles an alle → eine Kollisionsdomäne

STP (802.1D): Verhindert Schleifen bei redundanten Switches
  1. Root-Bridge: niedrigste Bridge-ID (Prio 2B + MAC 6B, niedrig=beste)
  2. Root-Port/Switch: günstigster Pfad zur Root (niedrigste Pfadkosten)
  3. Designated Port/Segment: günstigster Port zur Root pro LAN
  4. Rest → BLOCKING
  Zustände: Blocking→Listening→Learning→Forwarding (je ~15s)
  BPDUs: Austausch-Pakete (Multicast 01:80:C2:00:00:00)

VLAN: logische Trennung auf Switch (eigene Broadcast-Domänen)
  Port-basiert: Port → VLAN-ID zugeordnet
  Trunk: 802.1Q Tag (4B nach SrcMAC): EthType(0x8100)|Prio(3)|CFI(1)|VID(12)
  Inter-VLAN: braucht Router / Layer-3-Switch
```

## 12. DNS
```
Domain Name System: Domainname → IP-Adresse
Transport: UDP Port 53 (TCP für Zonentransfers)
Hierarchie: Root-Server → TLD-Server (.de,.com,.org) → Autoritative Server

Auflösung:
  Iterativ: Lokaler DNS fragt Root → bekommt Verweis auf TLD → fragt TLD → ...
  Rekursiv: Lokaler DNS delegiert gesamte Auflösung (Root-Server erlauben das selten!)

Record-Typen:
  A     = Hostname → IPv4    AAAA  = Hostname → IPv6
  MX    = Domain → Mailserver    CNAME = Alias → kanonischer Name
  NS    = Domain → zuständiger Nameserver   PTR = IP → Hostname (Reverse)

Caching: DNS-Antworten werden mit TTL gecacht → beschleunigt weitere Anfragen
```

## 13. HTTP & WEB
```
HTTP: Hypertext Transfer Protocol, TCP Port 80, HTTPS = Port 443
Zustandslos (Server merkt sich nichts) → Cookies für Zustand

Request-Methoden:
  GET:  Ressource anfordern (Header + Body)
  POST: Daten an Server senden (z.B. Formulardaten)
  HEAD: Nur Header anfordern (kein Body)

Statuscodes: 200 OK | 301 Moved Permanently | 304 Not Modified
             400 Bad Request | 404 Not Found | 500 Internal Server Error

Persistent vs Non-Persistent:
  Non-persistent: Neue TCP-Verbindung pro Objekt → 2 RTT pro Objekt
  Persistent: TCP-Verbindung bleibt offen → nur 1 RTT pro Objekt nach Aufbau
  Pipelining: Mehrere Requests ohne auf Antwort zu warten

RTT-Berechnung (persistent + Pipelining):
  1 RTT (TCP Aufbau) + 1 RTT (Index-Seite) + min{1, N} RTT (N Objekte)
  = 2 RTT (wenn N=0) oder 3 RTT (wenn N≥1)
  Optional: +1 RTT für Verbindungsabbau

Non-persistent HTTP: 2 RTT + Übertragungszeit pro Objekt
  (1 RTT TCP-Aufbau + 1 RTT Request/Response)
```

## 14. KRYPTOGRAPHIE
```
## 14. KRYPTOGRAPHIE

4 Ziele: Vertraulichkeit, Integrität, Authentizität, Verbindlichkeit

Symmetrisch (1 Key, schnell): AES 128/192/256, Blockchiffre
  ECB(unsicher!) CBC(+IV) CFB CTR(parallel) GCM(AES+MAC→Standard)
Asymmetrisch (Pub/Priv, langsam): RSA, DH, ECDHE
  Pub=verschl./Sig.prüfen | Priv=entschl./signieren
Hybrid: Asym.→Keyaustausch, dann Sym.→Daten (=TLS-Prinzip)

Hash: SHA-256/384, Einweg, feste Länge → Integrität
HMAC: Hash(Msg|Key) → Auth+Integrität (nur mit Key erzeugbar)

══ RSA REZEPT ══
1. Wähle Primzahlen p, q → n = p·q
2. z = (p-1)·(q-1)
3. Wähle e mit ggT(e,z) = 1 (teilerfremd)
4. Finde d mit (e·d) mod z = 1
   Trick: Prüfe k·z+1 ob durch e teilbar → d = (k·z+1)/e
   Bsp: p=11,q=5 → n=55, z=40, e=7 → 1·40+1=41/7? nein
   2·40+1=81? nein, 3·40+1=121? nein, 4·40+1=161/7=23 ✓ → d=23
Public=(e,n)=(7,55) | Private=(d,n)=(23,55)
Verschlüsseln: c = m^e mod n    (18^7 mod 55 = 17)
Entschlüsseln: m = c^d mod n    (17^23 mod 55 = 18)
Signieren: s = m^d mod n | Prüfen: m = s^e mod n

══ DIFFIE-HELLMAN REZEPT ══
Öffentlich: Primzahl p, Primitivwurzel g
1. Alice wählt geheim a, berechnet A = g^a mod p, sendet A
2. Bob wählt geheim b, berechnet B = g^b mod p, sendet B
3. Alice: K = B^a mod p | Bob: K = A^b mod p → gleicher Key!
Bsp: p=13, g=2, a=5, b=8
  A = 2^5 mod 13 = 6 | B = 2^8 mod 13 = 9
  Alice: K = 9^5 mod 13 = 3 | Bob: K = 6^8 mod 13 = 3 ✓

Zertifikat: CA bestätigt PubKey↔Server | PKI: RootCA→ZwischenCA→End | CRL=Widerruf
Kerberos: Client→AuthSrv(→TGT)→TGS(→Ticket)→Ressource
Challenge-Response: Nonce R senden→mit SharedKey verschlüsseln→prüfen
```

## 15. TLS / SSL
```
TLS: oberhalb TCP, Vertraulichkeit+Integrität+Auth, HTTPS=HTTP+TLS(Port 443)

Handshake (1 RTT, TLS 1.3):
  1) Client Hello: Cipher Suites, DH-Params, (opt. Client-Zert.)
  2) Server Hello: gewählte Suite, DH-Params, Server-Zertifikat
  3) Client prüft Zert., erzeugt Schlüssel, sendet sofort Daten

4 Schlüssel aus Master Secret (KDF):
  Kc,Mc (Client→Server) | Ks,Ms (Server→Client) | je Verschl.+MAC

Records: Datenstrom in Blöcke, jeder mit eigenem MAC+TLS-SeqNr
  → Schutz vor Replay+Reorder, verschlüsselt an TCP übergeben
0-RTT Resumption: schnell aber Replay-anfällig!

Cipher Suite z.B. TLS_AES_256_GCM_SHA384 (AES-Verschl, GCM+MAC, SHA-HMAC)
  TLS 1.3: nur 5 Suites, DH Pflicht (kein RSA-Schlüsselaustausch mehr)
```

## 16. VPN & IPSec
```
VPN (Virtual Private Network):
  Virtuelles privates Netz über öffentliches Internet
  Site-to-Site: Gateway ↔ Gateway (zwei Standorte verbinden)
  End-to-Site: Laptop ↔ Gateway (Fernzugriff auf Firmennetz)
  Gewährleistet: Vertraulichkeit, Authentifizierung, Integrität

IPSec (Schicht 3):
  Bei IPv6 Pflicht (bei IPv4 optional)
  IKE (Internet Key Exchange): Handelt Algorithmen + Keys aus
  AH (Authentication Header): Auth + Integrität, KEINE Verschlüsselung
  ESP (Encapsulating Security Payload): Auth + Integrität + Verschlüsselung

  Transportmodus: nur Payload verschlüsselt (Original-IP-Header bleibt)
  Tunnelmodus: GANZES Paket verschlüsselt + neuer IP-Header (für VPN Gateway)

SSL-VPN: nutzt HTTPS → funktioniert auch wenn alles außer Web gesperrt ist!
```

## 17. FIREWALL, ACL, IDS
```
Paketfilter (Firewall):
  Regeln basierend auf: Src-IP, Dst-IP, Src-Port, Dst-Port, Protokoll
  Aktionen: Accept (weiterleiten) | Drop (verwerfen) | Log (aufzeichnen)
  Stateless: jedes Paket einzeln geprüft
  Stateful: merkt sich Verbindungszustand (z.B. TCP-Verbindung aufgebaut?)

ACL (Access Control List) auf Cisco-Routern:
  Standard ACL: filtert nur nach Source-IP
  Extended ACL: filtert nach Src/Dst-IP + Src/Dst-Port + Protokoll

IDS (Intrusion Detection System): erkennt Angriffe
  Signaturbasiert: bekannte Angriffsmuster
  Anomaliebasiert: Abweichung vom Normalverhalten

NAT als Sicherheit: eingehende Pakete ohne Port-Mapping → verworfen
```

## 18. SOCKET-PROGRAMMIERUNG
```
TCP-Server:  socket() → bind() → listen() → accept() → recv/send → close()
TCP-Client:  socket() → connect() → send/recv → close()
UDP:         socket() → bind() → sendto()/recvfrom()  (keine Verbindung!)

Well-Known Ports: HTTP=80, HTTPS=443, DNS=53, SMTP=25, FTP=20/21,
                  SSH=22, DHCP=67/68, RIP=520, BGP=179, POP3=110, IMAP=143
```