IP-Subnetting und Binärkonvertierung im Linux-Terminal durchführen

Einführung

In diesem Labor meistern Sie die wesentlichen Fähigkeiten der IP-Adress-Subnetzbildung und der Binärkonvertierung über die Linux-Kommandozeile. Durch die Nutzung des interaktiven Python-Interpreters sammeln Sie praktische Erfahrungen mit den grundlegenden Berechnungen, die dem Computer-Networking zugrunde liegen, und bewegen sich dabei von theoretischem Wissen zur praktischen Anwendung in einer Terminalumgebung.

Sie beginnen mit der Konvertierung von IP-Adressen von der bekannten Punkt-Dezimal-Notation in ihre 32-Bit-Binärform und umgekehrt. Das Labor führt Sie dann durch die Übersetzung von CIDR-Subnetzmasken in ihre binären und Punkt-Dezimal-Äquivalente. Abschließend wenden Sie diese Fähigkeiten an, um die Netzwerk- und Host-Anteile einer gegebenen IP-Adresse zu identifizieren und die Gesamtzahl der nutzbaren Hosts und Subnetze innerhalb eines bestimmten CIDR-Blocks zu berechnen.

IP- und Subnetzmasken-Konvertierungen in Python durchführen

In diesem Schritt verwenden Sie den interaktiven Python-Interpreter, um mehrere wichtige Netzwerk-Konvertierungen durchzuführen. Sie lernen, wie Sie IP-Adressen zwischen Punkt-Dezimal- und Binärformaten konvertieren und wie Sie CIDR-Subnetzmasken in ihre vollständigen Binär- und Punkt-Dezimal-Darstellungen übersetzen. Dies geschieht alles in einer einzigen, kontinuierlichen Sitzung, um den Prozess zu optimieren.

Eine IPv4-Adresse ist eine 32-Bit-Zahl. Um sie für Menschen lesbar zu machen, wird sie als vier 8-Bit-Zahlen, sogenannte Oktette, dargestellt, die durch Punkte getrennt sind (z. B. 192.168.1.10). Jedes dieser Oktette kann in eine 8-Bit-Binärzahl konvertiert werden.

Öffnen Sie zunächst das Terminal und starten Sie den interaktiven Python-Interpreter. Die LabEx-Umgebung hat Python vorinstalliert. Geben Sie python3 ein und drücken Sie Enter.
```
python3
```
Sie sehen eine neue Eingabeaufforderung, >>>, die anzeigt, dass Sie sich nun im Python-Interpreter befinden.
```
Python 3.10.x (...)
Type "help", "copyright", "credits" or "license" for more information.
>>>
```

IP-Adresse von Punkt-Dezimal in Binär konvertieren

Üben wir die Konvertierung einer einzelnen Dezimalzahl in ihre Binärform. Wir verwenden die integrierte bin()-Funktion von Python. Geben Sie beispielsweise zur Konvertierung der Zahl 192 Folgendes an der Python-Eingabeaufforderung ein:
```
bin(192)
```
Python gibt die Binärdarstellung zurück, die mit 0b vorangestellt ist, um anzuzeigen, dass es sich um eine Binärzahl handelt.
```
'0b11000000'
```
Das Binäräquivalent von 192 ist 11000000.
Wenden wir dies nun auf eine vollständige IP-Adresse an, z. B. 192.168.1.10. Wir müssen jedes Oktett (192, 168, 1 und 10) einzeln konvertieren. Eine wichtige Regel bei IP-Adressierung ist, dass jedes Oktett durch genau 8 Bits dargestellt werden muss. Wenn eine Binärzahl weniger als 8 Bits hat, müssen Sie führende Nullen hinzufügen, um sie aufzufüllen.

Konvertieren wir jeden Teil:
- Für 192: bin(192) ergibt '0b11000000'. Dies sind bereits 8 Bits: 11000000.
- Für 168: bin(168) ergibt '0b10101000'. Dies sind ebenfalls 8 Bits: 10101000.
- Für 1: bin(1) ergibt '0b1'. Wir müssen dies auf 8 Bits auffüllen: 00000001.
- Für 10: bin(10) ergibt '0b1010'. Wir müssen dies auf 8 Bits auffüllen: 00001010.
Durch die Kombination dieser erhalten Sie die vollständige 32-Bit-Binärdarstellung der IP-Adresse 192.168.1.10:

11000000.10101000.00000001.00001010

Binäre IP-Adresse zurück in Punkt-Dezimal konvertieren

Nun führen wir die umgekehrte Operation durch. Um eine Binärzahl in eine Dezimalzahl zu konvertieren, verwenden wir die int()-Funktion von Python. Diese Funktion kann zwei Argumente annehmen: das erste ist die Zahl als Zeichenkette und das zweite ist die Basis dieser Zahl. Da wir von Binär (Basis-2) konvertieren, verwenden wir immer 2 als zweites Argument.

Versuchen wir, ein einzelnes binäres Oktett, 10101000, in Dezimal zu konvertieren.
```
int('10101000', 2)
```
Python führt die Konvertierung aus und zeigt das Dezimalergebnis an.
```
168
```
Konvertieren wir nun die vollständige 32-Bit-Binär-IP-Adresse aus dem vorherigen Schritt: 11000000.10101000.00000001.00001010. Sie müssen jedes 8-Bit-Oktett einzeln konvertieren.
- Konvertieren Sie das erste Oktett: int('11000000', 2), was 192 ergibt.
- Konvertieren Sie das zweite Oktett: int('10101000', 2), was 168 ergibt.
- Konvertieren Sie das dritte Oktett: int('00000001', 2), was 1 ergibt.
- Konvertieren Sie das vierte Oktett: int('00001010', 2), was 10 ergibt.
Durch die Kombination dieser Ergebnisse mit Punkten erhalten Sie die ursprüngliche Punkt-Dezimal-IP-Adresse: 192.168.1.10. Dies bestätigt, dass Ihre Konvertierungen in beide Richtungen korrekt sind.

CIDR-Subnetzmaske in ihre Binär- und Punkt-Dezimalform übersetzen

Eine Subnetzmaske ist eine 32-Bit-Zahl, die den Netzwerkanteil einer IP-Adresse vom Hostanteil unterscheidet. Die CIDR-Notation (Classless Inter-Domain Routing) ist eine Kurzschreibweise zur Darstellung einer Subnetzmaske.

Zum Beispiel bedeutet eine CIDR-Notation von /24, dass die ersten 24 Bits der 32-Bit-Subnetzmaske 1en sind und die restlichen Bits 0en sind.

Ermitteln wir die Binär- und Punkt-Dezimaldarstellung für eine /24-Subnetzmaske.
- Binär: Eine /24-Maske hat 24 aufeinanderfolgende 1en, gefolgt von 32 - 24 = 8 0en. In Oktette unterteilt sieht sie so aus: 11111111.11111111.11111111.00000000
Konvertieren wir nun diese Binärmaske in ihre Punkt-Dezimalform. Das erste Oktett besteht nur aus Einsen, 11111111.
```
int('11111111', 2)
```
Die Ausgabe ist 255. Das letzte Oktett besteht nur aus Nullen, 00000000.
```
int('00000000', 2)
```
Die Ausgabe ist 0. Daher ist eine /24-Subnetzmaske in Punkt-Dezimalnotation 255.255.255.0.
Versuchen wir ein komplexeres Beispiel, wie /26.
- Binär: Eine /26-Maske hat 26 1en, gefolgt von 32 - 26 = 6 0en. 11111111.11111111.11111111.11000000
- Die ersten drei Oktette bestehen nur aus 1en, was wir als 255 kennen. Konvertieren wir das letzte Oktett, 11000000, in Dezimal.
```
int('11000000', 2)
```
Die Ausgabe ist 192. Eine /26-Subnetzmaske ist also in Punkt-Dezimalnotation 255.255.255.192.
Wenn Sie mit den Konvertierungen fertig sind, können Sie den Python-Interpreter verlassen und zur normalen Terminal-Eingabeaufforderung zurückkehren, indem Sie exit() eingeben und Enter drücken.
```
exit()
```

Sie haben nun die zweiseitige Konvertierung zwischen Punkt-Dezimal- und Binär-IP-Adressen sowie CIDR-Subnetzmasken gemeistert, eine entscheidende Fähigkeit für jeden Netzwerkprofi.

Netzwerk- und Host-Anteile für eine IP-Adresse identifizieren

In diesem Schritt wenden Sie Ihr Wissen über Subnetzmasken an, um die Netzwerk- und Host-Anteile einer gegebenen IP-Adresse zu identifizieren. Die Hauptfunktion einer Subnetzmaske besteht darin, einem Computer mitzuteilen, welcher Teil einer IP-Adresse das Netzwerk und welcher Teil das spezifische Gerät (Host) in diesem Netzwerk identifiziert.

Dies wird durch eine bitweise logische AND-Operation erreicht. Der Computer nimmt die IP-Adresse (in Binärform) und die Subnetzmaske (in Binärform) und führt eine AND-Operation darauf aus. Das Ergebnis ist die Netzwerkadresse.

Die Regeln für eine bitweise AND sind einfach:

1 AND 1 = 1
1 AND 0 = 0
0 AND 1 = 0
0 AND 0 = 0

Im Wesentlichen ist das Ergebnis 1, nur wenn beide entsprechenden Bits 1 sind.

Verwenden wir ein praktisches Beispiel, um dies in Aktion zu sehen. Wir ermitteln die Netzwerkadresse für die IP-Adresse 192.168.1.74 mit einer /26-Subnetzmaske (255.255.255.192). Anstatt dies manuell im Interpreter zu tun, schreiben wir ein kleines Python-Skript, um die Berechnung durchzuführen.

Erstellen Sie zunächst eine neue Python-Skriptdatei namens network_calc.py in Ihrem Projektverzeichnis mit dem nano-Editor.
```
nano ~/project/network_calc.py
```

Kopieren Sie den folgenden Python-Code in den nano-Editor und fügen Sie ihn ein. Dieses Skript definiert die IP und die Maske, führt die AND-Operation für jedes Oktett durch und gibt das Ergebnis aus.

## Define the IP address and subnet mask octets
ip = [192, 168, 1, 74]
mask = [255, 255, 255, 192]

## Calculate the network address using a bitwise AND
network_addr = [ip[i] & mask[i] for i in range(4)]

## Format the output strings
ip_str = ".".join(map(str, ip))
network_str = ".".join(map(str, network_addr))

print(f"IP Address:      {ip_str}")
print(f"Subnet Mask:     /26 (255.255.255.192)")
print(f"Network Address: {network_str}")

Speichern Sie die Datei und beenden Sie nano, indem Sie Ctrl+O drücken, dann Enter und schließlich Ctrl+X.

Führen Sie nun Ihr Skript vom Terminal aus.

python3 ~/project/network_calc.py

Sie sehen die folgende Ausgabe, die das Ergebnis der AND-Operation klar zeigt:

IP Address:      192.168.1.74
Subnet Mask:     /26 (255.255.255.192)
Network Address: 192.168.1.64

Aus dieser Ausgabe können wir die verschiedenen Anteile identifizieren:

Netzwerkanteil: Die /26-Maske zeigt an, dass die ersten 26 Bits der Netzwerkanteil sind. Die berechnete Network Address (192.168.1.64) ist die Kennung für dieses spezifische Netzwerk.
Hostanteil: Die verbleibenden 32 - 26 = 6 Bits sind der Hostanteil. Diese 6 Bits identifizieren das spezifische Gerät (.74) innerhalb des Netzwerks 192.168.1.64.

Sie haben erfolgreich ein Skript zur Ermittlung der Netzwerkadresse verwendet und können nun konzeptionell zwischen dem Netzwerk- und dem Hostanteil einer IP-Adresse unterscheiden.

Nutzbare Hosts und Subnetze für eine gegebene CIDR berechnen

In diesem letzten Schritt lernen Sie, wie Sie zwei wesentliche Subnetting-Berechnungen durchführen: die Ermittlung der Anzahl nutzbarer Host-IP-Adressen innerhalb eines Subnetzes und die Ermittlung, wie viele Subnetze aus einem größeren Netzwerkblock erstellt werden können. Diese Berechnungen sind grundlegend für die Netzwerkplanung und -gestaltung.

Hier sind die wichtigsten Formeln:

Anzahl nutzbarer Hosts: Die Formel lautet 2^n - 2, wobei n die Anzahl der Host-Bits ist (die 0en in der Subnetzmaske). Wir ziehen 2 ab, da die erste Adresse in einem Subnetz (bei der alle Host-Bits 0 sind) als Netzwerkadresse reserviert ist und die letzte Adresse (bei der alle Host-Bits 1 sind) als Broadcast-Adresse reserviert ist. Keine davon kann einem Gerät zugewiesen werden.
Anzahl der Subnetze: Dies wird berechnet, wenn Sie ein größeres Netzwerk (z. B. ein /24) in kleinere aufteilen (z. B. /26). Die Formel lautet 2^m, wobei m die Anzahl der Bits ist, die Sie vom ursprünglichen Host-Anteil "ausgeliehen" haben, um die neue, spezifischere Subnetzmaske zu erstellen.

Erweitern wir unser network_calc.py-Skript, um diese Berechnungen für uns durchzuführen.

Öffnen Sie zunächst erneut die Datei network_calc.py mit dem nano-Editor.
```
nano ~/project/network_calc.py
```

Löschen Sie den vorhandenen Inhalt und ersetzen Sie ihn durch den folgenden Python-Code. Diese neue Version konzentriert sich auf die Berechnung von Host- und Subnetz-Anzahlen basierend auf einem gegebenen CIDR-Präfix.

## Define the CIDR prefix and the base network prefix
cidr_prefix = 26
base_prefix = 24 ## The original network we are subnetting from (e.g., a /24)

## --- Calculations ---

## 1. Calculate host bits
host_bits = 32 - cidr_prefix

## 2. Calculate usable hosts
## The ** operator is for exponentiation (power of)
if host_bits > 0:
    total_hosts = 2**host_bits
    usable_hosts = total_hosts - 2
else:
    total_hosts = 1
    usable_hosts = 1 ## For /31 and /32, rules are different, but we simplify here

## 3. Calculate subnet bits borrowed
subnet_bits = cidr_prefix - base_prefix

## 4. Calculate number of subnets
if subnet_bits >= 0:
    num_subnets = 2**subnet_bits
else:
    num_subnets = "N/A (Prefix is smaller than base)"


## --- Output ---
print(f"--- Subnet Calculations for a /{cidr_prefix} Network ---")
print(f"Host Bits: {host_bits}")
print(f"Total Hosts per Subnet: 2^{host_bits} = {total_hosts}")
print(f"Usable Hosts per Subnet: {total_hosts} - 2 = {usable_hosts}")
print("") ## Adds a blank line for readability
print(f"--- Subnetting from a /{base_prefix} Network ---")
print(f"Subnet Bits Borrowed: {subnet_bits}")
print(f"Number of Subnets Created: 2^{subnet_bits} = {num_subnets}")

Speichern Sie die Datei und beenden Sie nano, indem Sie Ctrl+O, Enter und Ctrl+X drücken.
Führen Sie das aktualisierte Skript von Ihrem Terminal aus.
```
python3 ~/project/network_calc.py
```

Das Skript gibt nun die berechneten Werte aus:

--- Subnet Calculations for a /26 Network ---
Host Bits: 6
Total Hosts per Subnet: 2^6 = 64
Usable Hosts per Subnet: 64 - 2 = 62

--- Subnetting from a /24 Network ---
Subnet Bits Borrowed: 2
Number of Subnets Created: 2^2 = 4

Diese Ausgabe zeigt deutlich, dass für ein /26-Netzwerk 6 Host-Bits vorhanden sind, was 2^6 = 64 Gesamtadressen ermöglicht. Nach der Reservierung der Netzwerk- und Broadcast-Adressen bleiben Ihnen 62 nutzbare Hosts übrig. Sie zeigt auch, dass, wenn Sie mit einem /24-Netzwerk begonnen haben, Sie 2 Bits ausgeliehen haben, um die /26-Maske zu erstellen, was zu 2^2 = 4 möglichen Subnetzen führt.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie grundlegende IP-Adress- und Subnetting-Berechnungen direkt im Linux-Terminal durchführen. Sie haben den interaktiven Python-Interpreter als leistungsstarkes Werkzeug genutzt, um IP-Adressen vom menschenlesbaren Punkt-Dezimalformat in ihre 32-Bit-Binäräquivalente und dann wieder zurück zu konvertieren. Dies beinhaltete die individuelle Konvertierung jedes Oktetts und die Sicherstellung der korrekten 8-Bit-Auffüllung. Sie haben auch geübt, CIDR-Subnetzmasken-Notation in ihre vollständige Binär- und Punkt-Dezimalform zu übersetzen.

Aufbauend auf diesen Konvertierungsfähigkeiten haben Sie diese auf wesentliche Netzwerkanalyseaufgaben angewendet. Sie haben gelernt, wie Sie die Netzwerk- und Host-Anteile einer IP-Adresse mithilfe der Subnetzmaske unterscheiden. Schließlich haben Sie die notwendigen Berechnungen durchgeführt, um die Anzahl der nutzbaren Host-Adressen und die Gesamtzahl der für ein Netzwerk verfügbaren Subnetze basierend auf seinem gegebenen CIDR-Präfix zu ermitteln, wodurch Ihr Verständnis der IP-Subnetting-Prinzipien gefestigt wurde.