Aufgaben A: Grundlagen Netzwerke [KSR Wiki]

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
==== Aufgaben A: Grundlagen Netzwerke ====

Abgabe via Teams.

=== Aufgabe A1: Unterseekabel ===

Ein typischer Schweizer Haushalt hat eine Internetverbindung von etwa $500$ Mbit / s. Wie viele solche Haushalte könnte man mit dem [[wpde>Marea_(Seekabel)|MAREA-Kabel]] versorgen, angenommen, dass alle gleichzeitig ihre Internetverbindung voll auslasten?

=== Aufgabe A2: Netzwerk mit direkten Verbindungen ===

   * Betrachte ein Netzwerk mit $n$ Geräten, welche alle direkt miteinander verbunden sind. Wie viele Verbindungen / Kabel sind nötig?
   * Entscheide selbst: Löse das Problem, indem du ...
      * eine mathematische Formel dafür herleitest (besser!) oder ...
      * einen Python-Code schreibst, der die Berechnung für dich übernimmt.
   * Wie viele Kabel benötigt man für ein Netzwerk mit ...
      * $5$ Geräten (kleiner Haushalt)?
      * $200$ Geräten (mittlere Firma)?
      * $30$ Milliarden Geräten (Internet)?

=== Aufgabe A3: Protokolle ===

Wo im echten Leben gibt es Protokolle? Mache *eigene* Beispiele.

==== Lösungen A ====
<nodisp 1>
++++Lösungen|

=== A1 ===

$320000$ Geräte: [[https://www.wolframalpha.com/input?i=160+Terabits+per+second+%2F+500+Megabits+per+second|Wolfram Alpha]]

=== A2 ===

Anzahl Verbindungen für $n$ Geräte:
$$A = \frac{n-1}{2} \cdot n$$
Tipp für Herleitung: Berechne explizit für einige Beispiele:
   * $n=5$: $A = 4 + 3 + 2 + 1 = 2 \cdot 5$
   * $n=6$: $A = 5 + 4 + 3 + 2 + 1 = 2.5 \cdot 6$
   * $n=7$: $A = 6 + 5 + 4 + 3 + 2 + 1 = 3 \cdot 7$

Mit Code:
<code python>
def anzahl_verbindungen(n):
    a = 0
    for i in range(1,n):
        a = a + i
    return a

print(anzahl_verbindungen(1000000))
</code>
Problem: Dauert sehr lange, kaum berechenbar für $30$ Mia. Geräte

++++
</nodisp>


==== Aufgaben B: Schichtenmodell ====


=== Aufgabe B1: WireShark Installieren ===

[[https://www.wireshark.org/|Wireshark]] ist ein freier und quelloffener Netzwerk-Monitor, mit dem sich der ganze Netzverkehr eines Geräts protokollieren lässt. 

  * Installiere Wireshark auf deinem Gerät.
  * Starte eine neue Capture mit leerem Capture-Filter - was siehst du?
  * Beende die Capture mit dem roten Stopp-Knopf {{:gf_informatik:web:internet:aufgaben_a:pasted:20231123-102010.png?nolink&100}}.

=== Aufgabe B2: HTTP-Verbindung Protokollieren ===

Viele Web-Verbindungen sind heute verschlüsselt, was es schwieriger macht, ihre Details zu protokollieren. Wir wollen unten eine unverschlüsselte HTTP-Verbindung protokollieren:

  * Starte eine Wireshark Capture mit dem Capture-Filter ''host laralei.ch'' - damit werden nur Verbindungen zum Server ''laralei.ch'' protokolliert.
  * Öffne ein neues Browser-Fenster und lade die Webseite ''http://laralei.ch''.
    * **Wichtig:** Die Adresse muss genau wie oben eingegeben werden - die meisten Browser wechseln sonst automatisch zu ''https://laralei.ch'', was die verschlüsselte Variante wäre.
  * Beende die Capture mit dem roten Stopp-Knopf.
  * Schau dir das Paket-Protokoll an.

Jedes Paket ist teil eines ineinander verschachtelten Gesprächs auf verschiedenen Ebenen. 
  * Auf der höchsten Ebene sprechen der Browser und der Webserver das Protokoll HTTP, um eine Webseite zu übertragen.
    * Wähle ein HTTP-Paket, das vom Server zurückgeschickt wurde, und zeige die Details (unten) des Pakets an.
    * Findest du in den Antworten des Servers Sprach-Elemente, die du kennst? Welche?
  * Auf der nächst-tieferen Ebene wird durch TCP ein bidirektionaler Datenstrom zwischen unserem Gerät und dem Gerät des Webservers organisiert.
    * Wähle das erste HTTP-Paket und zeige den Datenstrom an: {{:gf_informatik:web:internet:aufgaben_a:pasted:20231123-103615.png?nolink&400}}
    * Erkennst du das HTTP-Gespräch, das in diesem Datenstrom eingebettet ist?

==== Aufgaben C: IP-Adresse & Subnetzmaske ====


=== Aufgabe C1: IPv4-Adressen  ===

   1. Wie viele verschiedene IPv4-Adressen gibt es?
   1. Reicht dies aus, um alle Geräte im Internet eindeutig zu adressieren?

=== Aufgabe C2: Subnetzmaske ===

Eine typische Subnetzmaske in einem Heimnetzwerk ist $255.255.255.0$. Wie viele verschiedene Geräte kann man maximal haben in diesem Subnetz?

=== Aufgabe C3: Meine IP ===

   1. Stelle sicher, dass dein Computer mit dem eduroam-Netz der Schule verbunden ist. Bestimme dann die **(lokale) IP deines Geräts** in diesem Subnetz, sowie die **Subnetzmaske** (siehe unten).
   1. Trage deine IP mit Name in Tabelle an Wandtafel.
   1. Wie viele Geräte können sich mit diesem Subnetz verbinden? Reicht dies oder sollte man die Subnetzmaske anpassen?

Win: 
   * Terminal (Eingabeaufforderung): ipconfig

Mac:
   * Terminal: ifconfig
   * Systemeinstellung / Netzwerk / WLAN / Weitere Optionen / TCP/IP

=== Aufgabe C4: IPv4 ===

   1. Wie du gesehen hast, reicht der IPv4-Standard nicht aus, um alle Geräte im Internet zu adressieren. Aus wie vielen Bits müsste eine IP-Adresse mindestens bestehen, damit dies aktuell möglich ist?
   1. Tatsächlich wurde dieses Problem mit IPv6 bereits angegangen. Studiere den Eintrag zu IPv6 unten:

++++IPv6 Info|

Um die Knappheit der IPv4 Adressen zu lösen, wurde ab 1999 [[wpde>IPv6]] eingeführt, das 2<sup>128</sup> mögliche Adressen bietet. Damit ist also nicht nur möglich, jedes Gerät mit einer Adresse zu versorgen, sondern es hat sogar genügend Adressen für jedes Atom auf der Erdoberfläche...

IPv6-Adressen werden meist in Blöcken zu vier Hexadezimalzahlen (0-9,a-f) dargestellt: `2001:0db8:85a3:08d3:1319:8a2e:0370:7347`

Beim Routing und den anderen Netzwerkschichten ändert sich nur wenig im Vergleich zu IPv4

++++


=== Aufgabe C5 (CIDR) ===

Subnetzmasken können auch durch CIDR-Suffix kürzer ausgedrückt werden. Dieser Wert gibt die Anzahl Bits an, die in der Subnetzmaske $1$ sind. Z.B. steht $/10$ für $255.192.0.0$.

a) Wandle um $4-$Byte-Notation $\rightarrow$ CIDR-Notation:
   * i) $255.255.255.255$
   * ii) $255.255.255.0$
   * iii) $255.240.0.0$

b) Wandle um CIDR-Notation $\rightarrow$ $4-$Byte-Notation:
   * i) $/7$
   * ii) $/25$

=== Aufgabe C6: Subnetzmasken ===

   1. Wie viele Hosts kann ein Netzwerk mit Subnetzmaske $255.255.255.192$ haben?
   1. Wie viele Hosts kann ein Netzwerk mit CIDR /14 haben?
   1. Welche Subnetzmaske (normal und CIDR) sollte der Informatiker einer Firma mit ca. $5000$ Geräten für das Netzwerk der Firma wählen?
   


=== Zusatzaufgaben (Programmieren) ===

== a) ==
Schreibe ein Python-Programm (z.B. eine Funktion), welches für einen gegebenen CIDR-Suffix die entsprechende Subnetzmaske im $4$-Byte-Format (z.B. $255.192.0.0$) bestimmt und umgekehrt.

== b) ==

Programmiere nun eine eigene Auswahl der folgenden Funktionen:

   * Subnetzmaske in andere Formate umwandeln:
     * `subnet_dec_to_bin(subnet)`
     * `subnet_bin_to_dec(subnet_bin)`
     * `subnet_bin_to_cidr(subnet_bin)`
     * `subnet_dec_to_cidr(subnet)`
     * `cidr_to_subnet_bin(cidr)`
     * `cidr_to_subnet_dec(cidr)`
   * Abzahl mögliche Hosts für Subnetzmaske (in versch. Formaten) bestimmen:
     * `nr_hosts_from_subnet_bin(subnet_bin)`
     * `nr_hosts_from_subnet_dec(subnet_dec)`
     * `nr_hosts_from_cidr(cidr)`

== c) ==

Erweitere deinen Code aus a) und b) und implementiere einen **ultimativen Netzwerk-Rechner** im Stile der folgenden Website: https://www.heise.de/netze/tools/netzwerkrechner/
Man soll seine IP-Adresse und CIDR-Suffix angeben können und zurück erhalten:
   * Subnetzmaske (verwende Code von vorheriger Zusatzaufgabe)
   * Anzahl Hosts

Die weiteren Angaben (IP-Range, Broadcast, ...) können dann später hinzugefügt werden.
Falls du bereits über **Klassen/OOP** Bescheid weisst, wäre diese Aufgabe ein gutes Anwendungsbeispiel.

==== Lösungen C ====
<nodisp 1>

++++Aufgabe C1|

   1. $2^{32} \approx 4.3$ Milliarden
   1. Nein, da ca. $30$ Milliarden Geräte gibt

++++

++++Aufgabe C2|

Für Hosts stehen $8$ Bits zur verfügung, also $2^8 = 256$ Geräte.
Eigentlich: Muss $2$ abziehen, also nur 254, da die kleinste und grösste Adresse nicht an Geräte vergeben werden - später mehr dazu.

++++

++++Aufgabe C3|

   1. IP (Beispiel): $172.16.27.145$, Subnetzmaske:  $255.255.248.0$
   1. $11$ Bits für Hosts, also $2^{11}-2 = 2046$ Hosts. Ca. $600$ Personen an KSR, sollte also passen.

++++

++++Aufgabe C4|

$$2^x = 30 \cdot 10^9$$
$$x \approx 34.8$$
Also mind. $35$ Bit.

Gleichung kann gelöst werden mit dem Logarithmus oder einfach durch ausprobieren.

++++

++++Aufgabe C5|

a)
i) 32, ii) 24, iii) 12

b) i) 254.0.0.0, ii) 255.255.255.128

++++

++++Aufgabe C6|

   1. 62
   1. 262142 ($2^{32-14} - 2$)
   1. /19 = `11111111.11111111.11100000.00000000` = `255.255.224.0` ($2^{13} = 8192$)

++++


++++Zusatzaufgaben|

CIDR-Rechner:
<code python>

### SUBNET MASK DEC TO BINARY
def subnet_dec_to_bin(subnet):
    subnet_bin = []
    for nr in subnet.split('.'):
        nr = int(nr)
        b = bin(nr)[2:]
        while len(b) < 8: b = b + '0'
        subnet_bin.append(b)
    return '.'.join(subnet_bin)

def subnet_bin_to_dec(subnet_bin):
    subnet = []
    for nr in subnet_bin.split('.'):
        subnet.append(str(int(nr,2)))
    return '.'.join(subnet)

### GET CIDR OF SUBNET MASK
def subnet_bin_to_cidr(subnet_bin):
    return subnet_bin.count('1')

def subnet_dec_to_cidr(subnet):
    return subnet_bin_to_cidr(subnet_dec_to_bin(subnet))

### GET SUBNET MASK FROM CIDR
def cidr_to_subnet_bin(cidr):
    b = '1' * cidr
    while len(b) < 32: b = b + '0'
    return b[0:8] + '.' + b[8:16]  + '.' + b[16:24]  + '.' + b[24:] 

def cidr_to_subnet_dec(cidr):
    subnet_bin = cidr_to_subnet_bin(cidr)
    return subnet_bin_to_dec(subnet_bin)

### GET NR HOSTS
def nr_hosts_from_subnet_bin(subnet_bin):
    zeros = subnet_bin.count('0')
    return 2**zeros - 2

def nr_hosts_from_subnet_dec(subnet_dec):
    subnet_bin = subnet_dec_to_bin(subnet_dec)
    return nr_hosts_from_subnet_bin(subnet_bin)

def nr_hosts_from_cidr(cidr):
    subnet_bin = cidr_to_subnet_bin(cidr)
    return nr_hosts_from_subnet_bin(subnet_bin)

###
print(subnet_dec_to_bin("255.255.255.0"))
print(subnet_dec_to_cidr("255.192.0.0"))
print(subnet_bin_to_cidr("11111111.11111111.11111111.00000000"))
print(subnet_bin_to_dec("11111111.11000000.00000000.00000000"))
print(cidr_to_subnet_dec(10))
print(cidr_to_subnet_bin(10))

print(nr_hosts_from_subnet_bin("11111111.11111111.11111110.00000000"))

print(nr_hosts_from_subnet_dec("255.255.255.192"))
print(nr_hosts_from_cidr(12))
print(nr_hosts_from_cidr(19))
</code>
++++

</nodisp>

==== Aufgaben D: Vom Subnetz zum Internet ====

=== Aufgabe D1: Routing ===

   1. Auf welcher Netzwerk-Ebene erfolgt das Routing?
   1. Weshalb ändert sich deine IP-Adresse, wenn du vom KSR-Netz zu deinem Heimnetz wechselst?

=== Aufgabe D2: Gleiches Netzwerk oder nicht? ===

Löse diese Aufgabe mithilfe von Python/TigerJython (siehe Tipps unten).

In einem Subnetz mit Maske 255.255.255.192 hat ein Laptop die IP-Adresse 192.168.1.102. Aufgrund der Maske ist festgelegt, welche anderen IP-Adressen im gleichen Subnetz vergeben werden dürfen. Bestimme, welche der folgenden IP-Adressen in diesem Subnetz vergeben werden können und welche nicht:

   * 192.168.1.33
   * 192.168.1.87
   * 192.168.1.130

Begründe deine Antworten. Tipp 1: Es muss gerechnet werden, verwende dafür Python/TigerJython. Für mehr Tipps, siehe unten.

*Optional:* (aber sehr empfohlen): Schreibe einen Code, mit dem du einfach IP-Adressen und Subnetzmasken von der dezimalen 4-Byte-Notation in die Binär-Notation umwandeln kannst und umgekehrt. Schreibe z.B. folgende Funktionen:
<code python>
print(ip_dec_to_bin([133,162,149,238]))
print(ip_bin_to_dec("10000101.10100010.10010101.11101110"))
</code>

++++Tipps Python/TigerJython|

Mit Python/TigerJython kannst du ganz einfach Binärzahlen in Dezimalzahlen umrechnen und umgekehrt:
<code python>
print(int("1101",2)) # Binärstring in Dezimalzahl umwandeln
print(bin(13)) # Dezimalzahl in Binärstring umwandeln
</code>
Erinnerung: Auch mit allen grundlegenden Operationen kann einfach gerechnet werden:
<code python>
print(2*3*5*7*11)
print(2**15) # Potenzen, Hoch-Rechnen
</code>

++++

++++Tipps 2|

Erinnerung: Die Subnetzmaske gibt an, in welchen Bits die IP-Adressen eines Netzwerks übereinstimmen müssen. Daher musst du die Adressen und Maske zuerst in Binärzahlen umrechnen. Verwende dazu Python/TigerJython (siehe Tipp dazu).

++++

=== Aufgabe D3: I InformatikerIn ===

Du wurdest beauftragt, ein Heimnetzwerk einzurichten, an welches folgende Geräte angeschlossen werden sollen:

   * 5 Smartphones, 3 Laptops, 1 Desktop-Computer, 1 Drucker, 2 Fernsehboxen, 1 PlayStation, 1 Kühlschrank.
   * Platz für weitere 5 Geräte.

Auftrag:

   1. Welche **Subnetzmaske** wählst du? Wähle diese so restriktiv wie möglich, so dass sie aber genügend Platz für die geforderte Anzahl Geräte bietet. Gib die Subnetzmaske in den folgenden drei Formaten an: 4-Byte, binär, CIDR
   1. Mache eine **Skizze des Netzwerks**, an dessen Zentrum ein Switch steht. Weise jedem Gerät eine passende **lokale IP-Adresse** zu. Beachte: Diese muss mit der Subnetzmaske kompatibel sein.

=== Aufgabe D4: Umrechnungen Repetition ===

Solche Aufgabentypen hast du bereits gelöst.

   1. Wandle die Maske von der 4-Byte-Notation 255.254.0.0 in die CIDR-Notation um
   1. Wie viele IP-Adressen können im Subnetz aus 1. vergeben werden?
   1. Im Netzwerk einer Firma benutzen allerhöchstens $1000$ Geräte das Netzwerk. Welche Maske (in 4-Byte-Notation) sollte gewählt werden?
   1. In einem Netzwerk mit Maske /20 existiert ein Gerät mit IP 29.185.149.170. Ist es möglich, dass im gleichen Netzwerk auch die IP 29.185.144.42 vergeben wird?

=== Aufgabe D5: Broadcast und Netzwerk Adresse ===

Wir haben bereits gesehen, dass man beim Berechnen der Anzahl IP-Adressen, die innerhalb eines Subnetzes vergeben werden können, zwei abziehen muss. Dies kommt daher, dass zwei IP-Adressen fix vergeben sind:

   * Die kleinste mögliche erlaubte IP-Adresse ist die sogenannte **Netzwerk Adresse.** Diese kann man als die Adresse des gesamten Netzwerks betrachten.
   * Die grösste mögliche erlaubte IP-Adresse heisst **Broadcast Adresse.** Über diese kann man direkt alle Geräte des Subnetzes Adressieren.

In dieser Aufgabe geht es darum, für ein vorgegebenes Netzwerk diese beiden Spezialadressen zu ermitteln. Klicke auf "Tipps", um solche zu erhalten, falls du sie benötigen solltest.

++++Tipps|

Stelle die Maske und die vorgegebene IP-Adresse im Binärsystem dar. Verwende dafür wieder Python. Die Netzwerk Adresse und Broadcast Adressen stimmen in dem Teil, in dem die Maske aus Einsen besteht mit der vorgegebenen IP-Adresse überein. Um die Netzwerk Adresse zu erhalten, füllst du den Rest mit Nullen auf (kleinste mögliche erlaubte IP-Adresse. Wie ermittelt man die Broadcast Adresse?

++++

Ermittle die **Netzwerk Adresse** und die **Broadcast Adresse** für ein Netzwerk mit Maske ..., in dem die IP-Adresse ... vorkommt:

   1. Maske /24, IP-Adresse: 192.168.1.127
   1. Maske /20, IP-Adresse: 29.185.149.17
   1. In den beiden Netzwerken von 1. und 2.: Welches sind die kleinste und grösste IP-Adressen, die an normale Geräte vergeben werden können?

=== Aufgabe D6 - Routingtabelle ===

Ein Router hat die folgende Routing-Tabelle:

^ IP-Präfix ^ Router ^ Handlung ^
| 1.1.3.1/32 | -- | Paket empfangen (eigene Adresse) |
| 3.3.3.3/32 | -- | Paket empfangen (eigene Adresse) |
| 1.1.3.0/24 | -- | Direkt versenden über Netzwerkkarte 1, Ziel im gleichen Subnetz 1.1.3 |
| 3.3.3.0/24 | -- | Direkt versenden über Netzwerkkarte 2, Ziel im gleichen Subnetz 3.3.3 |
| 1.1.1.0/24 | 3.3.3.2 | Weiterleiten über 3.3.3.2 |
| 1.1.8.0/24 | 3.3.3.8 | Weiterleiten über 3.3.3.8 |
| 1.1.6.0/24 | 3.3.3.4 | Weiterleiten über 3.3.3.4 |
| 0.0.0.0/0 | 3.3.3.1 | Default-Route: An den Router (auch *Gateway*) 3.3.3.1 senden zur Weiterleitung |

Entscheide, welche Zeilen für Pakete mit folgenden Ziel-Adressen zum Tragen kommen:

  1. ''1.1.8.17''
  1. ''129.132.98.12''
  1. ''1.1.3.2''
  1. ''3.3.3.3''


  

==== Lösungen D ====

<nodisp 1>
<color blue>NODISP</color>


++++Aufgabe D1|
  1. Vermittlungsschicht
  1. Damit das Routing funktioniert, muss jedes Gerät eine IP-Adresse des Subnetzes haben, in dem es eingebunden wird.
++++

++++Aufgabe D2|

   * 192.168.1.33: nicht gleiches NW
   * 192.168.1.87: gleiches NW
   * 192.168.1.130: nicht gleiches NW


++++

++++Aufgabe D3|

Wichtig: Stelle sicher, dass alle IP-Adressen im gleichen Subnetz vorkommen können. Siehe dazu Aufgabe D2.

++++

++++Aufgabe D4|

   1. $15$
   1. $131070$
   1. 255.255.252.0
   1. Ja. Wandle IP-Adressen und Masken ins Binärsystem um, um dies zu zeigen! Verwende dazu Python.


++++

++++Aufgabe D5|

   1. Netzwerk Adresse: 192.168.1.0, Broadcast Adresse: 192.168.1.255
   1. Netzwerk Adresse: 29.185.144.0, Broadcast Adresse: 29.185.159.255
   1. 192.168.1.1 / 192.168.1.254 und 29.185.144.1 / 29.185.159.254


++++


++++Code IP bin <-> dec|

<code python>
def ip_dec_as_string(ip):
    st = ""
    for nr in ip:
        st += str(nr) + "."
    return st[0:len(st)-1]
 
def ip_dec_list_to_bin(ip):
    # [133,162,149,238] -> "10000101.10100010.10010101.11101110"
    bin_ip = ''
    for nr in ip:
        b = bin(nr)[2:]
        while len(b) < 8:
            b = '0' + b
        bin_ip += b + "."
    return bin_ip[0:len(bin_ip)-1]

def ip_dec_to_bin(ip):
    # "133.162.149.238" -> "10000101.10100010.10010101.11101110"
    ip = [int(x) for x in ip.split('.')]
    return ip_dec_list_to_bin(ip)

def ip_bin_to_dec_list(ip_bin):
    # "10000101.10100010.10010101.11101110" -> [133,162,149,238]
    ip = []
    ip_bin = ip_bin.split('.')
    for nr in ip_bin:
        ip.append(int(nr,2))
    return ip

def ip_bin_to_dec(ip_bin):
    # "10000101.10100010.10010101.11101110" -> "133.162.149.238"
    ip = ip_bin_to_dec_list(ip_bin)
    ip = [str(x) for x in ip]
    return '.'.join(ip)

def mask_bin_to_cidr(mask_bin):
    count = 0
    for x in mask_bin:
        if x == '1': count += 1
    return count

print(ip_dec_list_to_bin([133,162,149,238]))
print(ip_dec_to_bin("133.162.149.238"))
print(ip_bin_to_dec_list("10000101.10100010.10010101.11101110"))
print(ip_bin_to_dec("10000101.10100010.10010101.11101110"))

def ip_dec_same_network_all_dec(mask,ip_1,ip_2):
    cidr = mask_bin_to_cidr(ip_dec_to_bin(mask))
    ip_1 = ''.join(ip_dec_to_bin(ip_1).split('.'))
    ip_2 = ''.join(ip_dec_to_bin(ip_2).split('.'))
    for i in range(cidr):
        if ip_1[i] != ip_2[i]:
            return False
    return True

print(ip_dec_same_network_all_dec("255.255.255.192","192.168.1.102","192.168.1.33"))
print(ip_dec_same_network_all_dec("255.255.255.192","192.168.1.102","192.168.1.87"))
print(ip_dec_same_network_all_dec("255.255.255.192","192.168.1.102","192.168.1.130"))
</code>

++++

</nodisp>