Network and Security Basics Wiki ‐ Part 4 - itnett/FTD02H-N GitHub Wiki

Her er en samling av Python-skript som dekker alle de angitte temaene, med error-håndtering og omfattende kommentarer. Skriptene kan brukes som en verktøypakke for å forstå nettverksgrunnleggende, IPS/IDS-systemer, nettverksadressering, Ethernet-nettverk, IP-adressering, pakkesniffing, applikasjons- og transportprotokoller, DNS og DHCP, datatyper og modeller, datastrukturer og databeskyttelse.

1. network_basics.py - Forstå nettverksgrunnleggende rundt TCP/IP og OSI-modellene

# network_basics.py

import socket

def get_ip_address(url):
    """
    Få IP-adressen til et gitt domenenavn.
    
    Parametre:
    url (str): Domenenavnet
    
    Returverdi:
    str: IP-adressen til domenenavnet
    
    Feil:
    socket.gaierror: Kan ikke løse domenenavnet
    """
    try:
        ip_address = socket.gethostbyname(url)
        print(f"IP-adressen til {url} er {ip_address}.")
        return ip_address
    except socket.gaierror as e:
        print(f"Feil: Kan ikke løse domenenavnet {url}. Detaljer: {e}")
        return None

if __name__ == "__main__":
    # Testfunksjon
    get_ip_address("www.google.com")

2. ids_ips_difference.py - Beskrive forskjellene mellom IPS og IDS-systemer

# ids_ips_difference.py

class SecuritySystem:
    """
    Klasse for å representere et generisk sikkerhetssystem.
    """

    def __init__(self, name, system_type):
        """
        Initierer sikkerhetssystemet med navn og type.
        
        Parametre:
        name (str): Navnet på systemet
        system_type (str): Type system ("IDS" eller "IPS")
        """
        self.name = name
        self.system_type = system_type

    def detect_intrusion(self):
        """
        Simulerer deteksjon av inntrenging.
        """
        print(f"{self.name} ({self.system_type}) oppdaget en inntrenging!")

class IDS(SecuritySystem):
    """
    Klasse for å representere et Intrusion Detection System (IDS).
    """

    def __init__(self, name):
        super().__init__(name, "IDS")

    def notify_admin(self):
        """
        Varsler administrator om oppdaget inntrenging.
        """
        print(f"Administrator varslet av {self.name}.")

class IPS(SecuritySystem):
    """
    Klasse for å representere et Intrusion Prevention System (IPS).
    """

    def __init__(self, name):
        super().__init__(name, "IPS")

    def block_intrusion(self):
        """
        Blokkerer inntrengingen automatisk.
        """
        print(f"Inntrenging blokkert av {self.name}.")

if __name__ == "__main__":
    ids = IDS("Snort IDS")
    ips = IPS("Suricata IPS")

    # Eksempler på bruk
    ids.detect_intrusion()
    ids.notify_admin()

    ips.detect_intrusion()
    ips.block_intrusion()

3. network_addressing.py - Diskuter nettverksadressering på lag 2 og lag 3

# network_addressing.py

def mac_to_binary(mac_address):
    """
    Konverterer en MAC-adresse til binært format.
    
    Parametre:
    mac_address (str): MAC-adressen i formatet "XX:XX:XX:XX:XX:XX"
    
    Returverdi:
    str: Binær representasjon av MAC-adressen
    """
    try:
        binary_mac = ''.join(format(int(x, 16), '08b') for x in mac_address.split(':'))
        print(f"MAC-adressen {mac_address} i binært format er {binary_mac}.")
        return binary_mac
    except ValueError as e:
        print(f"Feil: Ugyldig MAC-adresseformat. Detaljer: {e}")
        return None

def ip_to_binary(ip_address):
    """
    Konverterer en IP-adresse til binært format.
    
    Parametre:
    ip_address (str): IP-adressen
    
    Returverdi:
    str: Binær representasjon av IP-adressen
    """
    try:
        binary_ip = ''.join(format(int(x), '08b') for x in ip_address.split('.'))
        print(f"IP-adressen {ip_address} i binært format er {binary_ip}.")
        return binary_ip
    except ValueError as e:
        print(f"Feil: Ugyldig IP-adresseformat. Detaljer: {e}")
        return None

if __name__ == "__main__":
    # Testfunksjoner
    mac_to_binary("00:1A:2B:3C:4D:5E")
    ip_to_binary("192.168.1.1")

4. ethernet_simulator.py - Beskrive hvordan Ethernet-nettverk fungerer

# ethernet_simulator.py

class EthernetFrame:
    """
    Klasse som representerer en Ethernet-ramme.
    """

    def __init__(self, destination_mac, source_mac, data):
        """
        Initierer en Ethernet-ramme med destinasjon, kilde og data.
        
        Parametre:
        destination_mac (str): MAC-adressen til mottakeren
        source_mac (str): MAC-adressen til avsenderen
        data (str): Dataen som sendes
        """
        self.destination_mac = destination_mac
        self.source_mac = source_mac
        self.data = data

    def send(self):
        """
        Simulerer sending av Ethernet-rammen.
        """
        print(f"Sender data fra {self.source_mac} til {self.destination_mac}: {self.data}")

if __name__ == "__main__":
    # Eksempel på å sende en Ethernet-ramme
    frame = EthernetFrame("00:1A:2B:3C:4D:5E", "5E:4D:3C:2B:1A:00", "Hello, Network!")
    frame.send()

5. ip_tools.py - Forstå IP-adressering, NAT og pakkesniffing

# ip_tools.py

from scapy.all import sniff

def packet_callback(packet):
    """
    Callback-funksjon for å håndtere pakkesniffing.
    
    Parametre:
    packet (Packet): Nettverkspakken som ble snappet opp
    """
    print(f"Pakkesniffing: {packet.summary()}")

def start_sniffing(interface):
    """
    Starter pakkesniffing på en spesifisert nettverksgrensesnitt.
    
    Parametre:
    interface (str): Navnet på nettverksgrensesnittet
    """
    try:
        print(f"Starter pakkesniffing på {interface}...")
        sniff(iface=interface, prn=packet_callback, count=10)
    except Exception as e:
        print(f"Feil: Kunne ikke starte pakkesniffing. Detaljer: {e}")

if __name__ == "__main__":
    # Start pakkesniffing
    start_sniffing("eth0")

Filnavn og Strukturforslag

Du kan lagre disse filene i en katalogstruktur som nedenfor:

network_tools/
├── network_basics.py
├── ids_ips_difference.py
├── network_addressing.py
├── ethernet_simulator.py
└── ip_tools.py

Konklusjon

Disse skriptene dekker de viktigste emnene i nettverkssikkerhet og tilbyr praktiske eksempler på hvordan man kan forstå og simulere konsepter som TCP/IP-rammeverket, IDS/IPS-systemer, nettverksadressering, Ethernet-nettverk, IP-adressering, NAT og pakkesniffing. Hvert skript er designet med omfattende feilhåndtering og kommentarer for å sikre klarhet og brukervennlighet.

Her er en samling av Python-skript som er laget for praktisk bruk i daglige oppgaver innen nettverkssikkerhet, nettverksadministrasjon, og databeskyttelse. Disse skriptene dekker spesifikke temaer som overvåking av nettverkstrafikk, testing av nettverkskonfigurasjoner, automatisering av nettverksoppgaver, og sikring av databaser.

1. network_monitor.py - Overvåkning av Nettverkstrafikk

Dette skriptet bruker Python-pakken scapy for å sniffe nettverkspakker på en bestemt grensesnitt og loggføre dem for videre analyse.

# network_monitor.py

from scapy.all import sniff
import logging

# Sett opp logging
logging.basicConfig(filename='network_traffic.log', level=logging.INFO, format='%(asctime)s - %(message)s')

def packet_logger(packet):
    """
    Logger detaljer om pakken som snappes opp.

    Parametre:
    packet (Packet): Nettverkspakken som snappes opp
    """
    logging.info(f"Pakkesniffing: {packet.summary()}")

def start_monitoring(interface):
    """
    Starter pakkesniffing på en spesifisert nettverksgrensesnitt.

    Parametre:
    interface (str): Navnet på nettverksgrensesnittet
    """
    try:
        print(f"Starter pakkesniffing på {interface}...")
        sniff(iface=interface, prn=packet_logger, store=0)
    except Exception as e:
        print(f"Feil: Kunne ikke starte pakkesniffing. Detaljer: {e}")

if __name__ == "__main__":
    # Spesifiser nettverksgrensesnittet du vil sniffe på, f.eks. "eth0"
    start_monitoring("eth0")

Bruksområde: Dette skriptet kan brukes til å overvåke nettverkstrafikk og logge den til en fil for sikkerhetsanalyser. Administratorer kan bruke denne informasjonen til å identifisere mistenkelige mønstre eller uvanlig nettverksaktivitet.

2. firewall_checker.py - Testing av Brannmurregler

Dette skriptet sjekker om spesifikke porter er åpne eller lukket på en brannmur for en gitt IP-adresse. Det kan brukes til å teste brannmurkonfigurasjoner og sikre at bare nødvendige tjenester er tilgjengelige.

# firewall_checker.py

import socket

def check_port(ip, port):
    """
    Sjekker om en spesifisert port er åpen på en gitt IP-adresse.

    Parametre:
    ip (str): IP-adressen som skal sjekkes
    port (int): Portnummeret som skal sjekkes

    Returverdi:
    bool: True hvis porten er åpen, False ellers
    """
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.settimeout(1)  # Timeout på 1 sekund
    try:
        result = sock.connect_ex((ip, port))
        if result == 0:
            print(f"Port {port} er åpen på {ip}.")
            return True
        else:
            print(f"Port {port} er lukket på {ip}.")
            return False
    except Exception as e:
        print(f"Feil: Kunne ikke sjekke port {port} på {ip}. Detaljer: {e}")
        return False
    finally:
        sock.close()

if __name__ == "__main__":
    # Test med en IP-adresse og en port
    check_port("192.168.1.1", 22)
    check_port("192.168.1.1", 80)

Bruksområde: Dette skriptet brukes til å verifisere brannmurkonfigurasjoner ved å teste om spesifikke porter er åpne eller lukket. Det hjelper nettverksadministratorer med å identifisere feilkonfigurasjoner som kan utgjøre en sikkerhetsrisiko.

3. dns_lookup.py - DNS-oppslag og Overvåking

Dette skriptet utfører DNS-oppslag for å hente IP-adressen til et gitt domenenavn. Det kan brukes til å sikre at DNS-oppslagene fungerer som forventet.

# dns_lookup.py

import socket

def dns_lookup(domain):
    """
    Utfører et DNS-oppslag for å hente IP-adressen til et gitt domenenavn.

    Parametre:
    domain (str): Domenenavnet som skal slås opp

    Returverdi:
    str: IP-adressen til domenenavnet
    """
    try:
        ip = socket.gethostbyname(domain)
        print(f"IP-adressen til {domain} er {ip}.")
        return ip
    except socket.gaierror as e:
        print(f"Feil: Kan ikke løse domenenavnet {domain}. Detaljer: {e}")
        return None

if __name__ == "__main__":
    # Test med et domenenavn
    dns_lookup("example.com")

Bruksområde: Dette skriptet hjelper nettverksadministratorer med å utføre DNS-oppslag for å sikre at DNS-servere fungerer korrekt. Det kan også brukes til å feilsøke problemer med DNS-løsning.

4. data_protection.py - Kryptering og Dekryptering av Data

Dette skriptet viser hvordan man kan kryptere og dekryptere data ved hjelp av Python-pakken cryptography. Det er nyttig for å beskytte sensitive data.

# data_protection.py

from cryptography.fernet import Fernet

def generate_key():
    """
    Genererer en krypteringsnøkkel og lagrer den i en fil.
    """
    key = Fernet.generate_key()
    with open("secret.key", "wb") as key_file:
        key_file.write(key)
    print("Krypteringsnøkkel generert og lagret i secret.key.")

def load_key():
    """
    Leser krypteringsnøkkelen fra en fil.

    Returverdi:
    bytes: Krypteringsnøkkelen
    """
    try:
        return open("secret.key", "rb").read()
    except FileNotFoundError:
        print("Feil: secret.key ikke funnet. Generer en nøkkel først.")
        return None

def encrypt_data(data):
    """
    Krypterer data ved hjelp av Fernet-algoritmen.

    Parametre:
    data (str): Dataen som skal krypteres

    Returverdi:
    bytes: Kryptert data
    """
    key = load_key()
    if key is None:
        return None
    f = Fernet(key)
    encrypted = f.encrypt(data.encode())
    print(f"Kryptert data: {encrypted}")
    return encrypted

def decrypt_data(encrypted_data):
    """
    Dekrypterer data ved hjelp av Fernet-algoritmen.

    Parametre:
    encrypted_data (bytes): Kryptert data

    Returverdi:
    str: Dekryptert data
    """
    key = load_key()
    if key is None:
        return None
    f = Fernet(key)
    decrypted = f.decrypt(encrypted_data).decode()
    print(f"Dekryptert data: {decrypted}")
    return decrypted

if __name__ == "__main__":
    # Generer en krypteringsnøkkel én gang
    generate_key()

    # Krypter og dekrypter data
    encrypted = encrypt_data("Sensitive information")
    if encrypted:
        decrypt_data(encrypted)

Bruksområde: Dette skriptet gir en praktisk metode for å beskytte sensitiv informasjon ved hjelp av kryptering. Det kan brukes av sikkerhetsansvarlige for å sikre at data lagret eller overført er kryptert og dermed beskyttet mot uautorisert tilgang.

5. database_backup.py - Backup og Gjenoppretting av MySQL Database

Dette skriptet tar sikkerhetskopier av en MySQL-database og gjenoppretter dem om nødvendig.

# database_backup.py

import os
import subprocess

def backup_database(user, password, database):
    """
    Tar en sikkerhetskopi av en MySQL-database.

    Parametre:
    user (str): MySQL-brukernavn
    password (str): MySQL-passord
    database (str): Navn på databasen som skal sikkerhetskopieres
    """
    try:
        backup_file = f"{database}_backup.sql"
        command = f"mysqldump -u {user} -p{password} {database} > {backup_file}"
        os.system(command)
        print(f"Sikkerhetskopiering av databasen '{database}' fullført.")
    except Exception as e:
        print(f"Feil: Kunne ikke ta sikkerhetskopi av databasen. Detaljer: {e}")

def restore_database(user, password, database, backup_file):
    """
    Gjenoppretter en MySQL-database fra en sikkerhetskopifil.

    Parametre:
    user (str): MySQL-brukernavn
    password (str): My

SQL-passord
    database (str): Navn på databasen som skal gjenopprettes
    backup_file (str): Navn på sikkerhetskopifilen
    """
    try:
        command = f"mysql -u {user} -p{password} {database} < {backup_file}"
        os.system(command)
        print(f"Gjenoppretting av databasen '{database}' fullført.")
    except Exception as e:
        print(f"Feil: Kunne ikke gjenopprette databasen. Detaljer: {e}")

if __name__ == "__main__":
    # Eksempel på sikkerhetskopiering og gjenoppretting
    backup_database("root", "password", "mydatabase")
    restore_database("root", "password", "mydatabase", "mydatabase_backup.sql")

Bruksområde: Dette skriptet brukes til å automatisere backup og gjenoppretting av MySQL-databaser. Det sikrer at data kan gjenopprettes i tilfelle feil, datatap eller angrep.

Oppsummering

Disse Python-skriptene dekker praktiske oppgaver knyttet til nettverksovervåking, testing av sikkerhetstiltak, DNS-oppslag, datakryptering, og databaseadministrasjon. Ved å bruke disse skriptene i dag-til-dag arbeid, kan nettverksadministratorer og sikkerhetspersonell forbedre deres evne til å håndtere nettverkssikkerhet, databeskyttelse og feilsøking effektivt.