20TD02Q Spyder - itnett/FTD02H-N GitHub Wiki

20TD02Q Spyder

For å dekke temaet "Nettverk 1" med fokus på LAN/WAN-teknologi, nettverkstopologier, OSI-modellen, nettverkskomponenter, IPv4 og IPv6, nettverksprotokoller, nettverkstjenester, trådløs teknologi og simuleringsverktøy, kan vi lage et Python-skript som simulerer og demonstrerer disse konseptene. Skriptet vil inkludere eksempler på oppsett av grunnleggende nettverk, feilsøking, sikkerhet og bruk av simuleringsverktøy som GNS3 eller Cisco Packet Tracer.

Komplett Skript for Nettverk 1

1. Grunnleggende Nettverksoppsett og Feilsøking

Dette skriptet bruker scapy for nettverksmanipulering og socket for grunnleggende nettverkskommunikasjon.

import logging
import socket
import subprocess
import os
from scapy.all import *

# Konfigurasjon
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# --- GRUNNLEGGENDE NETTVERKSOPPSETT ---
def configure_interface(interface, ip_address, subnet_mask):
    """Konfigurerer en nettverksgrensesnitt med en IP-adresse og subnettmaske."""
    try:
        subprocess.run(["sudo", "ifconfig", interface, ip_address, "netmask", subnet_mask, "up"], check=True)
        logger.info(f"Grensesnitt {interface} konfigurert med IP {ip_address}/{subnet_mask}")
    except subprocess.CalledProcessError as e:
        logger.error(f"Feil ved konfigurasjon av grensesnitt: {e}")

def ping_host(host):
    """Pinger en vert for å sjekke tilgjengelighet."""
    try:
        output = subprocess.check_output(["ping", "-c", "4", host], universal_newlines=True)
        logger.info(f"Ping resultat:\n{output}")
    except subprocess.CalledProcessError as e:
        logger.error(f"Ping mislyktes: {e}")

# --- FEILSØKING AV NETTVERK ---
def traceroute_host(host):
    """Utfører traceroute for å finne ruten til en vert."""
    try:
        output = subprocess.check_output(["traceroute", host], universal_newlines=True)
        logger.info(f"Traceroute resultat:\n{output}")
    except subprocess.CalledProcessError as e:
        logger.error(f"Traceroute mislyktes: {e}")

def capture_packets(interface, count=10):
    """Fanger nettverkspakker på en spesifisert grensesnitt."""
    try:
        packets = sniff(iface=interface, count=count)
        packets.show()
        wrpcap('captured_packets.pcap', packets)
        logger.info(f"Fanget {count} pakker på grensesnitt {interface}")
    except Exception as e:
        logger.error(f"Feil ved pakkeinnfanging: {e}")

# --- SIKKERHET I NETTVERK ---
def enable_firewall():
    """Aktiverer grunnleggende brannmurregler."""
    try:
        subprocess.run(["sudo", "ufw", "enable"], check=True)
        subprocess.run(["sudo", "ufw", "default", "deny"], check=True)
        subprocess.run(["sudo", "ufw", "allow", "22"], check=True)  # Tillater SSH
        logger.info("Grunnleggende brannmur aktivert.")
    except subprocess.CalledProcessError as e:
        logger.error(f"Feil ved aktivering av brannmur: {e}")

def disable_firewall():
    """Deaktiverer brannmuren."""
    try:
        subprocess.run(["sudo", "ufw", "disable"], check=True)
        logger.info("Brannmur deaktivert.")
    except subprocess.CalledProcessError as e:
        logger.error(f"Feil ved deaktivering av brannmur: {e}")

# --- HOVEDPROGRAM ---
def main():
    logger.info("Starter nettverksoppsett og feilsøking...")

    # Nettverksoppsett
    configure_interface('eth0', '192.168.1.10', '255.255.255.0')
    
    # Sjekk tilkobling med ping
    ping_host('8.8.8.8')

    # Feilsøking
    traceroute_host('8.8.8.8')
    capture_packets('eth0')

    # Sikkerhet
    enable_firewall()
    # ... utfør andre sikkerhetstester ...
    disable_firewall()

    logger.info("Nettverksoppsett og feilsøking fullført.")

if __name__ == "__main__":
    main()

Forklaring og forbedringer

  1. Grunnleggende nettverksoppsett:

    • configure_interface: Konfigurerer en nettverksgrensesnitt med en IP-adresse og subnettmaske ved hjelp av ifconfig.
    • ping_host: Pinger en vert for å sjekke tilgjengelighet.

  2. Feilsøking av nettverk:

    • traceroute_host: Utfører traceroute for å finne ruten til en vert.
    • capture_packets: Fanger nettverkspakker på en spesifisert grensesnitt ved hjelp av scapy.

  3. Sikkerhet i nettverk:

    • enable_firewall: Aktiverer grunnleggende brannmurregler ved hjelp av ufw.
    • disable_firewall: Deaktiverer brannmuren.

  4. Hovedprogram:

    • Skriptet kjører nettverksoppsett, feilsøking og sikkerhetstester.

Instruksjoner for kjøring

  1. Installer nødvendige pakker:

    • Sørg for å ha scapy installert:
    pip install scapy

  2. Kjør skriptet som superbruker (root):

    • På grunn av nettverkskonfigurasjon og pakkeinnfanging, må skriptet kjøres med superbrukerrettigheter:
    sudo python3 nettverk1.py

Dette skriptet gir en omfattende simulering og demonstrasjon av grunnleggende nettverksoppsett, feilsøking og sikkerhet, noe som gjør det egnet for bruk i både skole- og arbeidskontekster.

Absolutt! Her er en forbedret versjon av skriptet, med fokus på LAN/WAN-teknologi, nettverkstopologier, OSI-modellen, nettverkskomponenter, IPv4 og IPv6, nettverksprotokoller, nettverkstjenester, trådløs teknologi og simuleringsverktøy, samt en mer utfyllende forklaring:

import logging
import socket
import subprocess
import os
from scapy.all import *
import ipaddress

# Konfigurasjon
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# --- GRUNNLEGGENDE NETTVERKSOPPSETT (LAN) ---
def configure_lan_interface(interface, ip_address, subnet_mask):
    """Konfigurerer et LAN-grensesnitt med IP-adresse og subnettmaske."""
    try:
        subprocess.run(["sudo", "ip", "addr", "add", f"{ip_address}/{subnet_mask}", "dev", interface], check=True)
        subprocess.run(["sudo", "ip", "link", "set", "dev", interface, "up"], check=True)
        logger.info(f"LAN-grensesnitt {interface} konfigurert med IP {ip_address}/{subnet_mask}")
    except subprocess.CalledProcessError as e:
        logger.error(f"Feil ved konfigurasjon av LAN-grensesnitt: {e}")

# --- NETTVERKSTOPOLOGIER (Eksempel: Stjernetopologi) ---
def simulate_star_topology():
    """Simulerer en enkel stjernetopologi med en sentral switch og flere enheter."""
    # (Her kan du bruke scapy til å sende pakker mellom enheter for å illustrere kommunikasjon)
    logger.info("Simulering av stjernetopologi")
    # ... (Implementer pakkesending/mottak for å vise kommunikasjon)

# --- OSI-MODELLEN (Eksempel: Lag 2 - Datakoblingslaget) ---
def demonstrate_mac_address_resolution():
    """Demonstrerer MAC-adresseoppløsning (ARP)."""
    try:
        my_mac = get_if_hwaddr(conf.iface)  # Får MAC-adressen til det lokale grensesnittet
        logger.info(f"Min MAC-adresse: {my_mac}")

        target_ip = "192.168.1.1"  # IP-adressen du vil løse opp
        target_mac = getmacbyip(target_ip)
        if target_mac:
            logger.info(f"MAC-adresse for {target_ip}: {target_mac}")
        else:
            logger.warning(f"Kunne ikke finne MAC-adresse for {target_ip}")
    except Exception as e:
        logger.error(f"Feil ved MAC-adresseoppløsning: {e}")

# --- IPv4 OG IPv6 ---
def display_ip_information():
    """Viser IPv4- og IPv6-informasjon for systemet."""
    try:
        ipv4 = socket.gethostbyname(socket.gethostname())
        ipv6 = socket.getaddrinfo(socket.gethostname(), None, socket.AF_INET6)[0][4][0]
        logger.info(f"IPv4-adresse: {ipv4}")
        logger.info(f"IPv6-adresse: {ipv6}")
    except Exception as e:
        logger.error(f"Feil ved henting av IP-informasjon: {e}")

# ... (Legg til flere funksjoner for å dekke andre emner som nettverksprotokoller,
#     nettverkstjenester, trådløs teknologi, og simuleringsverktøy)

# --- HOVEDPROGRAM ---
def main():
    logger.info("Starter nettverkssimulering...")

    # LAN-oppsett
    configure_lan_interface("eth0", "192.168.1.10", "255.255.255.0")

    # Nettverkstopologier
    simulate_star_topology()

    # OSI-modellen
    demonstrate_mac_address_resolution()

    # IPv4 og IPv6
    display_ip_information()

    # ... (Kjør funksjoner for andre emner)

    logger.info("Nettverkssimulering fullført.")

if __name__ == "__main__":
    main()

Forbedringer:

  • Strukturert etter emner: Skriptet er organisert i funksjoner som fokuserer på spesifikke emner, noe som gjør det lettere å lese og vedlikeholde.
  • LAN-fokus: Bruker ip-kommandoen for mer moderne og fleksibel LAN-konfigurasjon.
  • Eksempler: Inkluderer grunnleggende eksempler på hvordan du kan simulere nettverkstopologier og demonstrere OSI-konsepter.
  • Utvidelsesmuligheter: Gir et rammeverk for å legge til flere funksjoner for å dekke andre emner i pensum.

Neste steg:

  1. Implementer funksjoner for de resterende emnene: Legg til funksjoner for å demonstrere nettverksprotokoller (TCP/IP, UDP, etc.), nettverkstjenester (DHCP, DNS, etc.), trådløs teknologi (Wi-Fi, Bluetooth), og bruk av simuleringsverktøy (GNS3, Packet Tracer).
  2. Utvid simuleringer: Gjør simuleringene mer avanserte ved å inkludere flere enheter, forskjellige topologier, og mer realistisk nettverkstrafikk.
  3. Tilpass til pensum: Sørg for at skriptet dekker alle de spesifikke emnene og læringsmålene i "Nettverk 1"-kurset ditt.

Gi meg beskjed hvis du har noen spørsmål eller ønsker ytterligere forbedringer!

Forbedret Python-skript for Nettverk 1 med Fokus på LAN/WAN-teknologi, Nettverkstopologier, OSI-modellen, IPv4 og IPv6, Nettverksprotokoller og Nettverkstjenester

Dette skriptet dekker de viktigste emnene i "Nettverk 1" kurset, inkludert praktiske eksempler og simuleringer.

import logging
import socket
import subprocess
import os
from scapy.all import *

# Konfigurasjon
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# --- GRUNNLEGGENDE NETTVERKSOPPSETT (LAN) ---
def configure_lan_interface(interface, ip_address, subnet_mask):
    """Konfigurerer et LAN-grensesnitt med IP-adresse og subnettmaske."""
    try:
        subprocess.run(["sudo", "ip", "addr", "add", f"{ip_address}/{subnet_mask}", "dev", interface], check=True)
        subprocess.run(["sudo", "ip", "link", "set", "dev", interface, "up"], check=True)
        logger.info(f"LAN-grensesnitt {interface} konfigurert med IP {ip_address}/{subnet_mask}")
    except subprocess.CalledProcessError as e:
        logger.error(f"Feil ved konfigurasjon av LAN-grensesnitt: {e}")

# --- NETTVERKSTOPOLOGIER (Eksempel: Stjernetopologi) ---
def simulate_star_topology():
    """Simulerer en enkel stjernetopologi med en sentral switch og flere enheter."""
    logger.info("Simulering av stjernetopologi")
    # Eksempel: Sender ARP-pakker fra en sentral switch til flere enheter
    switch_ip = "192.168.1.1"
    for i in range(2, 6):
        target_ip = f"192.168.1.{i}"
        pkt = Ether(dst="ff:ff:ff:ff:ff:ff") / ARP(psrc=switch_ip, pdst=target_ip)
        sendp(pkt, iface="eth0")
        logger.info(f"Sendt ARP-pakke til {target_ip}")

# --- OSI-MODELLEN (Eksempel: Lag 2 - Datakoblingslaget) ---
def demonstrate_mac_address_resolution():
    """Demonstrerer MAC-adresseoppløsning (ARP)."""
    try:
        my_mac = get_if_hwaddr(conf.iface)  # Får MAC-adressen til det lokale grensesnittet
        logger.info(f"Min MAC-adresse: {my_mac}")

        target_ip = "192.168.1.1"  # IP-adressen du vil løse opp
        target_mac = getmacbyip(target_ip)
        if target_mac:
            logger.info(f"MAC-adresse for {target_ip}: {target_mac}")
        else:
            logger.warning(f"Kunne ikke finne MAC-adresse for {target_ip}")
    except Exception as e:
        logger.error(f"Feil ved MAC-adresseoppløsning: {e}")

# --- IPv4 OG IPv6 ---
def display_ip_information():
    """Viser IPv4- og IPv6-informasjon for systemet."""
    try:
        ipv4 = socket.gethostbyname(socket.gethostname())
        ipv6 = socket.getaddrinfo(socket.gethostname(), None, socket.AF_INET6)[0][4][0]
        logger.info(f"IPv4-adresse: {ipv4}")
        logger.info(f"IPv6-adresse: {ipv6}")
    except Exception as e:
        logger.error(f"Feil ved henting av IP-informasjon: {e}")

# --- NETTVERKSPROTOKOLLER ---
def demonstrate_tcp_connection(target_ip, target_port):
    """Demonstrerer opprettelsen av en TCP-tilkobling."""
    try:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
            s.connect((target_ip, target_port))
            logger.info(f"Opprettet TCP-tilkobling til {target_ip}:{target_port}")
            s.sendall(b"Hello, World!")
            data = s.recv(1024)
            logger.info(f"Mottatt data: {data}")
    except Exception as e:
        logger.error(f"Feil ved opprettelse av TCP-tilkobling: {e}")

# --- NETTVERKSTJENESTER (DNS-oppslag) ---
def perform_dns_lookup(domain):
    """Utfører DNS-oppslag for et gitt domenenavn."""
    try:
        ip_address = socket.gethostbyname(domain)
        logger.info(f"IP-adresse for {domain}: {ip_address}")
    except socket.error as e:
        logger.error(f"DNS-oppslag mislyktes for {domain}: {e}")

# --- TRÅDLØS TEKNOLOGI ---
def scan_wifi_networks():
    """Skanner tilgjengelige WiFi-nettverk (krever root-tilgang)."""
    try:
        networks = subprocess.check_output(["sudo", "iwlist", "scan"], universal_newlines=True)
        logger.info("Tilgjengelige WiFi-nettverk:\n" + networks)
    except subprocess.CalledProcessError as e:
        logger.error(f"Feil ved skanning av WiFi-nettverk: {e}")

# --- HOVEDPROGRAM ---
def main():
    logger.info("Starter nettverkssimulering...")

    # LAN-oppsett
    configure_lan_interface("eth0", "192.168.1.10", "24")

    # Nettverkstopologier
    simulate_star_topology()

    # OSI-modellen
    demonstrate_mac_address_resolution()

    # IPv4 og IPv6
    display_ip_information()

    # Nettverksprotokoller
    demonstrate_tcp_connection("192.168.1.1", 80)

    # Nettverkstjenester
    perform_dns_lookup("example.com")

    # Trådløs teknologi
    scan_wifi_networks()

    logger.info("Nettverkssimulering fullført.")

if __name__ == "__main__":
    main()

Forklaring og forbedringer

  1. Grunnleggende nettverksoppsett (LAN):

    • configure_lan_interface: Konfigurerer en nettverksgrensesnitt med IP-adresse og subnettmaske ved hjelp av ip-kommandoen.

  2. Nettverkstopologier (Stjernetopologi):

    • simulate_star_topology: Simulerer en enkel stjernetopologi ved å sende ARP-pakker fra en sentral switch til flere enheter.

  3. OSI-modellen (Lag 2 - Datakoblingslaget):

    • demonstrate_mac_address_resolution: Demonstrerer MAC-adresseoppløsning ved å bruke ARP.

  4. IPv4 og IPv6:

    • display_ip_information: Viser IPv4- og IPv6-adresser for systemet.

  5. Nettverksprotokoller (TCP):

    • demonstrate_tcp_connection: Demonstrerer opprettelsen av en TCP-tilkobling og sender en melding.

  6. Nettverkstjenester (DNS):

    • perform_dns_lookup: Utfører DNS-oppslag for et gitt domenenavn.

  7. Trådløs teknologi (WiFi):

    • scan_wifi_networks: Skanner tilgjengelige WiFi-nettverk (krever root-tilgang).

Instruksjoner for kjøring

  1. Installer nødvendige pakker:

    • Sørg for å ha scapy installert:
    pip install scapy

  2. Kjør skriptet som superbruker (root):

    • På grunn av nettverkskonfigurasjon og pakkeinnfanging, må skriptet kjøres med superbrukerrettigheter:
    sudo python3 nettverk1.py

Dette skriptet gir en omfattende simulering og demonstrasjon av grunnleggende nettverksoppsett, feilsøking og sikkerhet, samt de viktigste emnene i "Nettverk 1" kurset, noe som gjør det egnet for bruk i både skole- og arbeidskontekster.

Kort beskrivelse av koden

Dette Python-skriptet simulerer og demonstrerer flere grunnleggende nettverkskonsepter og operasjoner. Det dekker LAN-oppsett, nettverkstopologier, OSI-modellen, IPv4- og IPv6-konfigurasjon, nettverksprotokoller, nettverkstjenester og trådløs teknologi. Koden inkluderer funksjoner for konfigurasjon, feilsøking og sikkerhet i nettverk, med bruk av scapy og socket bibliotekene.

Faktisk kode

import logging
import socket
import subprocess
import os
from scapy.all import *

# Konfigurasjon
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# --- GRUNNLEGGENDE NETTVERKSOPPSETT (LAN) ---
def configure_lan_interface(interface, ip_address, subnet_mask):
    """Konfigurerer et LAN-grensesnitt med IP-adresse og subnettmaske."""
    try:
        subprocess.run(["sudo", "ip", "addr", "add", f"{ip_address}/{subnet_mask}", "dev", interface], check=True)
        subprocess.run(["sudo", "ip", "link", "set", "dev", interface, "up"], check=True)
        logger.info(f"LAN-grensesnitt {interface} konfigurert med IP {ip_address}/{subnet_mask}")
    except subprocess.CalledProcessError as e:
        logger.error(f"Feil ved konfigurasjon av LAN-grensesnitt: {e}")

# --- NETTVERKSTOPOLOGIER (Eksempel: Stjernetopologi) ---
def simulate_star_topology():
    """Simulerer en enkel stjernetopologi med en sentral switch og flere enheter."""
    logger.info("Simulering av stjernetopologi")
    # Eksempel: Sender ARP-pakker fra en sentral switch til flere enheter
    switch_ip = "192.168.1.1"
    for i in range(2, 6):
        target_ip = f"192.168.1.{i}"
        pkt = Ether(dst="ff:ff:ff:ff:ff:ff") / ARP(psrc=switch_ip, pdst=target_ip)
        sendp(pkt, iface="eth0")
        logger.info(f"Sendt ARP-pakke til {target_ip}")

# --- OSI-MODELLEN (Eksempel: Lag 2 - Datakoblingslaget) ---
def demonstrate_mac_address_resolution():
    """Demonstrerer MAC-adresseoppløsning (ARP)."""
    try:
        my_mac = get_if_hwaddr(conf.iface)  # Får MAC-adressen til det lokale grensesnittet
        logger.info(f"Min MAC-adresse: {my_mac}")

        target_ip = "192.168.1.1"  # IP-adressen du vil løse opp
        target_mac = getmacbyip(target_ip)
        if target_mac:
            logger.info(f"MAC-adresse for {target_ip}: {target_mac}")
        else:
            logger.warning(f"Kunne ikke finne MAC-adresse for {target_ip}")
    except Exception as e:
        logger.error(f"Feil ved MAC-adresseoppløsning: {e}")

# --- IPv4 OG IPv6 ---
def display_ip_information():
    """Viser IPv4- og IPv6-informasjon for systemet."""
    try:
        ipv4 = socket.gethostbyname(socket.gethostname())
        ipv6 = socket.getaddrinfo(socket.gethostname(), None, socket.AF_INET6)[0][4][0]
        logger.info(f"IPv4-adresse: {ipv4}")
        logger.info(f"IPv6-adresse: {ipv6}")
    except Exception as e:
        logger.error(f"Feil ved henting av IP-informasjon: {e}")

# --- NETTVERKSPROTOKOLLER ---
def demonstrate_tcp_connection(target_ip, target_port):
    """Demonstrerer opprettelsen av en TCP-tilkobling."""
    try:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
            s.connect((target_ip, target_port))
            logger.info(f"Opprettet TCP-tilkobling til {target_ip}:{target_port}")
            s.sendall(b"Hello, World!")
            data = s.recv(1024)
            logger.info(f"Mottatt data: {data}")
    except Exception as e:
        logger.error(f"Feil ved opprettelse av TCP-tilkobling: {e}")

# --- NETTVERKSTJENESTER (DNS-oppslag) ---
def perform_dns_lookup(domain):
    """Utfører DNS-oppslag for et gitt domenenavn."""
    try:
        ip_address = socket.gethostbyname(domain)
        logger.info(f"IP-adresse for {domain}: {ip_address}")
    except socket.error as e:
        logger.error(f"DNS-oppslag mislyktes for {domain}: {e}")

# --- TRÅDLØS TEKNOLOGI ---
def scan_wifi_networks():
    """Skanner tilgjengelige WiFi-nettverk (krever root-tilgang)."""
    try:
        networks = subprocess.check_output(["sudo", "iwlist", "scan"], universal_newlines=True)
        logger.info("Tilgjengelige WiFi-nettverk:\n" + networks)
    except subprocess.CalledProcessError as e:
        logger.error(f"Feil ved skanning av WiFi-nettverk: {e}")

# --- HOVEDPROGRAM ---
def main():
    logger.info("Starter nettverkssimulering...")

    # LAN-oppsett
    configure_lan_interface("eth0", "192.168.1.10", "24")

    # Nettverkstopologier
    simulate_star_topology()

    # OSI-modellen
    demonstrate_mac_address_resolution()

    # IPv4 og IPv6
    display_ip_information()

    # Nettverksprotokoller
    demonstrate_tcp_connection("192.168.1.1", 80)

    # Nettverkstjenester
    perform_dns_lookup("example.com")

    # Trådløs teknologi
    scan_wifi_networks()

    logger.info("Nettverkssimulering fullført.")

if __name__ == "__main__":
    main()

Struktur og flyt

  1. Grunnleggende nettverksoppsett (LAN):
    • configure_lan_interface: Konfigurerer et LAN-grensesnitt med IP-adresse og subnettmaske.
  2. Nettverkstopologier (Stjernetopologi):
    • simulate_star_topology: Simulerer en stjernetopologi ved å sende ARP-pakker fra en sentral switch til flere enheter.
  3. OSI-modellen (Lag 2 - Datakoblingslaget):
    • demonstrate_mac_address_resolution: Demonstrerer MAC-adresseoppløsning ved å bruke ARP.
  4. IPv4 og IPv6:
    • display_ip_information: Viser IPv4- og IPv6-adresser for systemet.
  5. Nettverksprotokoller (TCP):
    • demonstrate_tcp_connection: Demonstrerer opprettelsen av en TCP-tilkobling og sender en melding.
  6. Nettverkstjenester (DNS):
    • perform_dns_lookup: Utfører DNS-oppslag for et gitt domenenavn.
  7. Trådløs teknologi (WiFi):
    • scan_wifi_networks: Skanner tilgjengelige WiFi-nettverk.

Forbindelser og avhengigheter

  • main funksjonen kaller de ulike funksjonene i en bestemt rekkefølge for å konfigurere nettverket, simulere topologi, demonstrere OSI-modellen, vise IP-informasjon, demonstrere TCP-tilkobling, utføre DNS-oppslag og skanne WiFi-nettverk.
  • Funksjonene er selvstendige, men følger en logisk rekkefølge for nettverksoppsett og feilsøking.
  • Logging brukes for å dokumentere utførelsen og eventuelle feil.

Mermaid-diagram

graph TD
    A[Main Function] --> B[Configure LAN Interface]
    A --> C[Simulate Star Topology]
    A --> D[Demonstrate MAC Address Resolution]
    A --> E[Display IP Information]
    A --> F[Demonstrate TCP Connection]
    A --> G[Perform DNS Lookup]
    A --> H[Scan WiFi Networks]
    
    B --> I[configure_lan_interface]
    C --> J[simulate_star_topology]
    D --> K[demonstrate_mac_address_resolution]
    E --> L[display_ip_information]
    F --> M[demonstrate_tcp_connection]
    G --> N[perform_dns_lookup]
    H --> O[scan_wifi_networks]

Dette diagrammet viser hovedfunksjonen som kaller de forskjellige funksjonene i skriptet, som hver representerer en spesifikk nettverksoperasjon eller konsept.