Maven_super_30_LeseTolkeKode_6 - itnett/FTD02H-N GitHub Wiki

La oss lage en rekke mindre Python-skript som dekker flere emner relatert til programmering og sikkerhet, samtidig som de også tar for seg spesifikke temaer fra utdanningen din som IoT, cybersikkerhet, nettverk og virtualisering. Disse skriptene vil berøre de grunnleggende aspektene ved programmering (som datastrukturer, OOP, API-er osv.) samtidig som de gir praktisk innsikt i emner som er relevante for din utdanning.

1. Programstruktur og Grunnleggende Sikkerhetsprinsipper

Dette skriptet viser en enkel strukturert tilnærming for å håndtere grunnleggende sikkerhetskontroller som brukervalgte passord og hash-koding for lagring.

import hashlib

def hash_password(password):
    # Hashes a password using SHA-256
    return hashlib.sha256(password.encode()).hexdigest()

def check_password(stored_hash, provided_password):
    # Checks if the provided password matches the stored hash
    return stored_hash == hash_password(provided_password)

def main():
    print("Welcome to Secure Password Storage!")
    
    # Get user password
    password = input("Enter a password to store: ")
    stored_hash = hash_password(password)
    
    print(f"Your hashed password is: {stored_hash}")
    
    # Check password
    test_password = input("Re-enter your password to check: ")
    if check_password(stored_hash, test_password):
        print("Password matched!")
    else:
        print("Password did not match!")

if __name__ == "__main__":
    main()

2. Objektorientert Programmering og IoT Enhetssimulering

Her lager vi en klasse for en IoT-enhet, som for eksempel en temperatursensor. Dette skriptet simulerer innsamling av data fra en sensor og sender dem til en API-tjeneste.

import random
import requests

class IoTDevice:
    def __init__(self, name, device_type):
        self.name = name
        self.device_type = device_type
        self.data = 0
    
    def generate_data(self):
        # Simulate data generation
        if self.device_type == "Temperature Sensor":
            self.data = random.uniform(20.0, 30.0)
        elif self.device_type == "Humidity Sensor":
            self.data = random.uniform(30.0, 70.0)
        return self.data

    def send_data(self, api_url):
        # Send data to an API endpoint
        payload = {'device': self.name, 'type': self.device_type, 'data': self.data}
        response = requests.post(api_url, json=payload)
        return response.status_code

# Main script
def main():
    sensor = IoTDevice("Sensor1", "Temperature Sensor")
    data = sensor.generate_data()
    print(f"Generated Data: {data} °C")
    
    # Simulate sending data to an API
    api_url = "http://example.com/api/data"
    status = sensor.send_data(api_url)
    
    if status == 200:
        print("Data sent successfully!")
    else:
        print("Failed to send data.")

if __name__ == "__main__":
    main()

3. Filbehandling og Logging for Servervedlikehold

Dette skriptet simulerer logging av systemhendelser som kan brukes i servervedlikehold og feilsøking.

import os
import logging
from datetime import datetime

# Setup logging
log_filename = 'server_log.txt'
logging.basicConfig(filename=log_filename, level=logging.INFO, format='%(asctime)s - %(message)s')

def check_disk_space():
    # Simulate disk space check
    total, used, free = 100, 75, 25  # Example values in GB
    return total, used, free

def log_event(event):
    logging.info(event)

def main():
    print("Server Maintenance Log")
    
    # Check disk space
    total, used, free = check_disk_space()
    log_event(f"Disk space check: Total: {total}GB, Used: {used}GB, Free: {free}GB")
    
    # Simulate more server events
    log_event("System backup completed successfully.")
    log_event("Detected unauthorized access attempt.")
    
    # Read and display log file
    with open(log_filename, 'r') as f:
        print(f.read())

if __name__ == "__main__":
    main()

4. Nettverkstopologier og Simuleringsverktøy med GUI

Dette skriptet bruker tkinter for å lage et GUI som visualiserer en enkel nettverkstopologi med LAN/WAN.

import tkinter as tk

class NetworkSimulationGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("Network Topology Simulation")

        # Create canvas for drawing
        self.canvas = tk.Canvas(root, width=600, height=400)
        self.canvas.pack()

        # Draw LAN components
        self.draw_network()

    def draw_network(self):
        # Drawing LAN components
        self.canvas.create_rectangle(50, 150, 150, 250, fill="lightblue", outline="black")
        self.canvas.create_text(100, 200, text="Router", font=("Helvetica", 14))

        self.canvas.create_oval(200, 100, 300, 200, fill="lightgreen", outline="black")
        self.canvas.create_text(250, 150, text="Switch", font=("Helvetica", 14))

        self.canvas.create_rectangle(350, 50, 450, 150, fill="lightcoral", outline="black")
        self.canvas.create_text(400, 100, text="Server", font=("Helvetica", 14))

        self.canvas.create_rectangle(350, 250, 450, 350, fill="lightyellow", outline="black")
        self.canvas.create_text(400, 300, text="Workstation", font=("Helvetica", 14))

        # Connect components with lines
        self.canvas.create_line(150, 200, 200, 150, width=2)  # Router to Switch
        self.canvas.create_line(300, 150, 350, 100, width=2)  # Switch to Server
        self.canvas.create_line(300, 150, 350, 300, width=2)  # Switch to Workstation

# Main script
if __name__ == "__main__":
    root = tk.Tk()
    app = NetworkSimulationGUI(root)
    root.mainloop()

5. Datasikkerhet og Kryptering

Dette skriptet demonstrerer hvordan man kan bruke kryptering for å sikre sensitive data, for eksempel passord eller filer.

from cryptography.fernet import Fernet

def generate_key():
    return Fernet.generate_key()

def encrypt_data(data, key):
    fernet = Fernet(key)
    encrypted = fernet.encrypt(data.encode())
    return encrypted

def decrypt_data(encrypted_data, key):
    fernet = Fernet(key)
    decrypted = fernet.decrypt(encrypted_data).decode()
    return decrypted

def main():
    # Generate encryption key
    key = generate_key()
    print(f"Generated Key: {key}")

    # Encrypt a message
    message = "This is a secret message."
    encrypted_message = encrypt_data(message, key)
    print(f"Encrypted Message: {encrypted_message}")

    # Decrypt the message
    decrypted_message = decrypt_data(encrypted_message, key)
    print(f"Decrypted Message: {decrypted_message}")

if __name__ == "__main__":
    main()

6. Protokoller og API-integrasjon

Dette skriptet viser hvordan man kan bruke et API for å integrere en IoT-enhet med en skytjeneste som Azure IoT Hub.

import requests

def send_data_to_iot_hub(device_id, data):
    # Example Azure IoT Hub endpoint (replace with real endpoint)
    url = f"https://your-iot-hub.azure-devices.net/devices/{device_id}/messages/events?api-version=2018-06-30"
    
    headers = {
        "Authorization": "Bearer YOUR_ACCESS_TOKEN",
        "Content-Type": "application/json"
    }
    
    response = requests.post(url, json=data, headers=headers)
    
    if response.status_code == 204:
        print("Data sent successfully!")
    else:
        print(f"Failed to send data: {response.status_code}")

def main():
    device_id = "MyIoTDevice"
    data = {
        "temperature": 22.5,
        "humidity": 60
    }
    
    send_data_to_iot_hub(device_id, data)

if __name__ == "__main__":
    main()

7. Virtualisering og Sikkerhet i Hypervisorer

Dette skriptet overvåker virtuelle maskiner på en hypervisor og sjekker ressursbruk.

import psutil

def monitor_virtual_machines():
    for vm in psutil.virtual_memory():
        print(f"Virtual Machine: {vm.name}")
        print(f"  CPU Usage: {vm.cpu_percent}%")
        print(f"  Memory Usage: {vm.memory_percent}%")
        print(f"  Disk Usage: {vm.disk_percent}%")
        print(f"  Network Usage: {vm.network_percent}%\n")

def main():
    print("Monitoring Virtual Machines on Hypervisor...\n")
    monitor_virtual_machines()



if __name__ == "__main__":
    main()

8. Bruk av SQL for Databasesystemer og Backup

Dette skriptet viser hvordan man kan bruke SQL til å sikkerhetskopiere data i en database.

import sqlite3
from datetime import datetime

def backup_database(db_name, backup_dir):
    conn = sqlite3.connect(db_name)
    backup_name = f"{backup_dir}/backup_{datetime.now().strftime('%Y%m%d%H%M%S')}.db"
    
    with open(backup_name, 'w') as backup_file:
        for line in conn.iterdump():
            backup_file.write('%s\n' % line)
    
    print(f"Backup created: {backup_name}")
    conn.close()

def main():
    db_name = "example.db"
    backup_dir = "backups"
    backup_database(db_name, backup_dir)

if __name__ == "__main__":
    main()

9. Automation in Linux System Administration

Dette skriptet demonstrerer hvordan man kan bruke Python for å automatisere brukeradministrasjon på en Linux-server.

import subprocess

def create_user(username):
    try:
        subprocess.run(['sudo', 'adduser', username], check=True)
        print(f"User {username} created successfully.")
    except subprocess.CalledProcessError:
        print(f"Failed to create user {username}.")

def delete_user(username):
    try:
        subprocess.run(['sudo', 'deluser', '--remove-home', username], check=True)
        print(f"User {username} deleted successfully.")
    except subprocess.CalledProcessError:
        print(f"Failed to delete user {username}.")

def main():
    while True:
        action = input("Enter 'create' to create a user or 'delete' to delete a user: ").strip().lower()
        username = input("Enter username: ").strip()
        
        if action == 'create':
            create_user(username)
        elif action == 'delete':
            delete_user(username)
        else:
            print("Invalid action.")

if __name__ == "__main__":
    main()

10. Automated Security Audits

Dette skriptet gjennomfører en enkel sikkerhetsrevisjon av en Linux-server ved å sjekke konfigurasjoner og loggfiler.

import subprocess

def check_firewall_status():
    result = subprocess.run(['sudo', 'ufw', 'status'], capture_output=True, text=True)
    print("Firewall Status:\n", result.stdout)

def check_failed_logins():
    result = subprocess.run(['sudo', 'grep', 'Failed password', '/var/log/auth.log'], capture_output=True, text=True)
    print("Failed Login Attempts:\n", result.stdout)

def main():
    print("Running Security Audit...\n")
    
    check_firewall_status()
    check_failed_logins()

    print("Security Audit Completed.")

if __name__ == "__main__":
    main()

Sammendrag

Disse skriptene gir en rekke praktiske eksempler som dekker både grunnleggende og avanserte emner innen programmering og IT-drift. De er laget for å hjelpe deg med å forstå hvordan ulike programmeringsteknikker kan brukes i praktiske scenarier som er relevante for din utdanning, inkludert IoT, cybersikkerhet, nettverksadministrasjon, virtualisering, og databaser.

Lesing, Tolkning og Forklaring av Koden

La oss gå gjennom koden som ble presentert tidligere og deretter forklare hvordan den kan utvides for å dekke samtlige temaer og læringsmål fra programmeringskurset.

1. Grunnleggende Sikkerhetsprinsipper

  • Koden: Det første skriptet handler om hashing av passord, som er en grunnleggende sikkerhetsmetode.
  • Forklaring: Hashing er en enveis funksjon som konverterer et passord til en fast lengde streng som ikke kan konverteres tilbake. Dette sikrer at passordene lagres sikkert.
  • Utvidelse: Dette skriptet kan utvides til å inkludere salting, der en tilfeldig verdi (salt) legges til passordet før hashing, for å forbedre sikkerheten. Skriptet kan også legge til funksjoner for å håndtere flere brukere og lagre hashed passord i en database.

2. Objektorientert Programmering og IoT Enhetssimulering

  • Koden: Dette skriptet lager en IoTDevice-klasse som simulerer innsamling og sending av data fra en IoT-enhet.
  • Forklaring: Objektorientert programmering (OOP) er en programmeringsmodell basert på objekter og klasser. Skriptet viser hvordan man kan definere en klasse med attributter (f.eks. navn, type) og metoder (f.eks. generate_data, send_data).
  • Utvidelse: For å dekke UML (Unified Modeling Language), kan vi lage diagrammer som beskriver klassen og dens interaksjoner med andre klasser. Skriptet kan også utvides til å inkludere flere sensorer, lagring av data i en database, og komplekse beslutningsalgoritmer for databehandling.

3. Filbehandling og Logging for Servervedlikehold

  • Koden: Skriptet logger systemhendelser til en tekstfil, som kan brukes til vedlikehold og feilsøking.
  • Forklaring: Filbehandling innebærer å åpne, lese, skrive og lukke filer. Logging er en metode for å lagre informasjon om hendelser som skjer under kjøring av et program.
  • Utvidelse: Dette skriptet kan utvides til å støtte ulike loggnivåer (info, warning, error), og loggene kan også lagres i et databaseformat som SQLite eller sendes til en ekstern logging-tjeneste.

4. Nettverkstopologier og Simuleringsverktøy med GUI

  • Koden: Skriptet bruker tkinter til å lage et GUI som visualiserer en enkel nettverkstopologi.
  • Forklaring: GUI-utvikling er viktig for å lage interaktive brukergrensesnitt. tkinter er et standard Python-bibliotek for å lage enkle GUI-er. Nettverkstopologier kan visualiseres for å forstå hvordan nettverksenheter er koblet sammen.
  • Utvidelse: For å utvikle et mer avansert GUI, kan du integrere flere nettverkselementer, tillate brukeren å interagere med topologien, og inkludere simulering av nettverkstrafikk og feil.

5. Datasikkerhet og Kryptering

  • Koden: Skriptet viser hvordan man bruker cryptography-biblioteket til å kryptere og dekryptere data.
  • Forklaring: Kryptering er prosessen med å konvertere data til en form som ikke kan leses uten en dekrypteringsnøkkel. Dette sikrer konfidensialiteten til data.
  • Utvidelse: Utvid dette skriptet til å inkludere forskjellige krypteringsalgoritmer (AES, RSA), nøkkelhåndtering, og implementer funksjoner for å sikre kommunikasjon mellom IoT-enheter og servere.

6. Protokoller og API-integrasjon

  • Koden: Skriptet sender data fra en IoT-enhet til en API-tjeneste som Azure IoT Hub.
  • Forklaring: API-er lar ulike programvarekomponenter kommunisere med hverandre. Dette skriptet simulerer sending av data fra en enhet til en skytjeneste.
  • Utvidelse: Skriptet kan utvides til å støtte flere API-er, håndtere feil i kommunikasjon, og inkludere autentisering og autorisering for å sikre at bare autoriserte enheter kan sende data.

7. Virtualisering og Sikkerhet i Hypervisorer

  • Koden: Dette skriptet overvåker ressursbruken til virtuelle maskiner på en hypervisor.
  • Forklaring: Virtualisering lar deg kjøre flere virtuelle maskiner på en enkelt fysisk maskin. Dette skriptet viser hvordan man kan overvåke ressursbruken til disse maskinene.
  • Utvidelse: Skriptet kan utvides til å inkludere flere typer overvåkning, som nettverkstrafikk, lagringsbruk, og alarmfunksjoner som varsler administratorer om eventuelle problemer.

8. SQL for Databasesystemer og Backup

  • Koden: Skriptet bruker SQL for å sikkerhetskopiere data i en SQLite-database.
  • Forklaring: SQL (Structured Query Language) brukes til å administrere og manipulere relasjonsdatabaser. Dette skriptet viser hvordan man kan lage en sikkerhetskopi av en database.
  • Utvidelse: Utvid skriptet til å inkludere flere databaseoperasjoner som normalisering, indeksering, og brukeradministrasjon. Implementer også automatiske sikkerhetskopieringsfunksjoner med tidsplanlegging.

9. Automation in Linux System Administration

  • Koden: Dette skriptet viser hvordan man kan automatisere brukeradministrasjon på en Linux-server ved å bruke Python.
  • Forklaring: Automatisering i systemadministrasjon sparer tid og reduserer menneskelige feil. Skriptet bruker subprocess for å kjøre Linux-kommandoer for å opprette og slette brukere.
  • Utvidelse: Utvid skriptet til å inkludere flere administrasjonsoppgaver som sikkerhetsoppdateringer, backup, og oppsett av nettverkstjenester som DNS og DHCP.

10. Automated Security Audits

  • Koden: Dette skriptet gjennomfører en enkel sikkerhetsrevisjon av en Linux-server.
  • Forklaring: Sikkerhetsrevisjoner er kritiske for å sikre at et system er beskyttet mot trusler. Dette skriptet sjekker statusen til brannmuren og logger mislykkede påloggingsforsøk.
  • Utvidelse: Skriptet kan utvides til å inkludere flere revisjonskontroller som sårbarhetsskanning, sjekking av konfigurasjonsfiler for sikkerhetshull, og automatisert utbedring av funn.

Hvordan Utvide Skriptene for å Dekke Samtlige Tema og Læringsmål

For å dekke alle de angitte temaene og læringsmålene i programmeringskurset, kan hvert skript utvides og kombineres med mer komplekse funksjoner som er relevante for kursinnholdet.

  • Programstrukturer og Datastrukturer: Lag mer komplekse datastrukturer som køer, stakker, lister, og trær, og vis hvordan disse kan brukes i nettverksalgoritmer eller databehandling i IoT-enheter.

  • Bibliotek: Utforsk flere Python-biblioteker som numpy for numeriske beregninger, pandas for dataanalyse, og matplotlib for datavisualisering. Implementer funksjoner for å behandle og analysere store datamengder fra sensorer eller serverlogger.

  • Funksjoner og metoder: Bygg skript med komplekse funksjoner som inkapsulerer algoritmer for risikostyring eller nettverksoptimalisering.

  • Debugging, testing og unntaksbehandling: Implementer enhetstesting ved hjelp av unittest eller pytest, og legg til unntaksbehandling for å sikre at skriptene håndterer feil på en kontrollert måte.

  • API: Integrer skriptene med flere eksterne API-er, som værdata for IoT-enheter, eller automatiseringsverktøy for serveradministrasjon.

  • GUI: Utvikle mer komplekse GUI-er for overvåking og administrasjon av nettverk, databaser og IoT-enheter, og inkluder sanntidsovervåkning og kontrollpaneler.

  • Filbehandling: Utvid filbehandlingsskriptene for å inkludere backup, komprimering, og sikkerhetskontroller på filer som inneholder sensitiv informasjon.

  • Datasikkerhet: Bygg flere sikkerhetsfunksjoner, inkludert nettverkssikkerhet, kryptering av datakommunikasjon, og sikre lagring av sensitive data.

Ved å kombinere og utvide disse skriptene, vil du være i stand til å dekke et bredt spekter av emner og ferdigheter som er nødvendige for å oppnå læringsmålene i programmeringskurset.

Nå skal vi optimalisere skriptene for å dekke alle læringsmålene, samtidig som vi legger til detaljert linje-for-linje-kommentering for å hjelpe deg med å lese og tolke koden.

1. Grunnleggende Sikkerhetsprinsipper - Utvidet Hashing Skript

import hashlib
import os

def generate_salt():
    """
    Generer en salt-verdi for å sikre at like passord ikke får samme hash.
    """
    return os.urandom(16)  # Genererer 16 bytes med tilfeldig data

def hash_password(password, salt):
    """
    Hash et passord med SHA-256 og en salt-verdi.
    """
    return hashlib.sha256(salt + password.encode()).hexdigest()

def check_password(stored_hash, provided_password, salt):
    """
    Sjekk om det oppgitte passordet matcher den lagrede hash-verdien.
    """
    return stored_hash == hash_password(provided_password, salt)

def main():
    print("Welcome to Secure Password Storage!")
    
    # Få brukerpassord og generer salt
    password = input("Enter a password to store: ")
    salt = generate_salt()  # Generer en salt-verdi
    stored_hash = hash_password(password, salt)  # Hash passordet med saltet
    
    print(f"Your hashed password is: {stored_hash}")
    
    # Sjekk passord
    test_password = input("Re-enter your password to check: ")
    if check_password(stored_hash, test_password, salt):
        print("Password matched!")
    else:
        print("Password did not match!")

if __name__ == "__main__":
    main()

Forklaring:

  • generate_salt: Genererer en salt-verdi som legges til passordet før det hashes. Dette sikrer at like passord ikke gir samme hash-verdi.
  • hash_password: Kombinerer saltet med passordet og bruker SHA-256 hashing.
  • check_password: Sammenligner den lagrede hash-verdien med den nyopprettede hash-verdien fra det oppgitte passordet.

2. Objektorientert Programmering og IoT Enhetssimulering - Utvidet med UML og Flere Sensortyper

import random
import requests
from datetime import datetime

class IoTDevice:
    def __init__(self, name, device_type):
        """
        Initialiserer en IoT-enhet med navn og type.
        """
        self.name = name
        self.device_type = device_type
        self.data = None
        self.timestamp = None
    
    def generate_data(self):
        """
        Generer tilfeldig data basert på enhetstype.
        """
        if self.device_type == "Temperature Sensor":
            self.data = random.uniform(20.0, 30.0)
        elif self.device_type == "Humidity Sensor":
            self.data = random.uniform(30.0, 70.0)
        elif self.device_type == "Pressure Sensor":
            self.data = random.uniform(950.0, 1050.0)
        
        self.timestamp = datetime.now().isoformat()  # Legger til et tidsstempel
        return self.data

    def send_data(self, api_url):
        """
        Send generert data til et API-endepunkt.
        """
        payload = {
            'device': self.name, 
            'type': self.device_type, 
            'data': self.data,
            'timestamp': self.timestamp
        }
        response = requests.post(api_url, json=payload)
        return response.status_code

# Hovedscriptet
def main():
    # Oppretter flere sensorer
    sensors = [
        IoTDevice("TempSensor1", "Temperature Sensor"),
        IoTDevice("HumidSensor1", "Humidity Sensor"),
        IoTDevice("PressureSensor1", "Pressure Sensor")
    ]
    
    api_url = "http://example.com/api/data"  # Simulert API-endepunkt

    for sensor in sensors:
        data = sensor.generate_data()
        print(f"{sensor.name} generated data: {data} {sensor.device_type.split()[0]}")
        
        # Sender data til API
        status = sensor.send_data(api_url)
        if status == 200:
            print(f"Data sent successfully for {sensor.name}!")
        else:
            print(f"Failed to send data for {sensor.name}.")

if __name__ == "__main__":
    main()

Forklaring:

  • generate_data: Genererer data basert på sensortypen. Her utvidet med flere typer sensorer (f.eks. trykksensor).
  • send_data: Sender data til et API-endepunkt med tillegg av tidsstempel.
  • main: Oppretter flere sensorer, genererer data og sender data til et API.

3. Filbehandling og Logging for Servervedlikehold - Utvidet med SQLite Logging

import os
import logging
import sqlite3
from datetime import datetime

# Setup logging
log_filename = 'server_log.db'  # Bruker SQLite database for logging
conn = sqlite3.connect(log_filename)
cursor = conn.cursor()

# Oppretter loggtabell om den ikke eksisterer
cursor.execute('''
CREATE TABLE IF NOT EXISTS logs (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    timestamp TEXT,
    event TEXT
)
''')

def log_event(event):
    """
    Logger en hendelse i SQLite-databasen med tidsstempel.
    """
    timestamp = datetime.now().isoformat()
    cursor.execute("INSERT INTO logs (timestamp, event) VALUES (?, ?)", (timestamp, event))
    conn.commit()

def check_disk_space():
    """
    Simulerer en sjekk av diskplass.
    """
    total, used, free = 100, 75, 25  # Eksempelverdier i GB
    event = f"Disk space check: Total: {total}GB, Used: {used}GB, Free: {free}GB"
    log_event(event)
    return total, used, free

def read_logs():
    """
    Leser og skriver ut loggene fra SQLite-databasen.
    """
    cursor.execute("SELECT * FROM logs")
    rows = cursor.fetchall()
    for row in rows:
        print(row)

def main():
    print("Server Maintenance Log")
    
    # Sjekker diskplass
    check_disk_space()
    
    # Simulerer flere serverhendelser
    log_event("System backup completed successfully.")
    log_event("Detected unauthorized access attempt.")
    
    # Leser loggene
    read_logs()

if __name__ == "__main__":
    main()

Forklaring:

  • SQLite Logging: I stedet for en tekstfil, logger vi hendelser i en SQLite-database for bedre strukturering og spørringsmuligheter.
  • log_event: Legger til hendelser i databasen med tidsstempel.
  • read_logs: Leser loggene fra databasen og skriver dem ut.

4. Nettverkstopologier og Simuleringsverktøy med GUI - Utvidet med Flere Nettverkskomponenter

import tkinter as tk

class NetworkSimulationGUI:
    def __init__(self, root):
        """
        Initialiserer GUI for nettverkssimulering.
        """
        self.root = root
        self.root.title("Network Topology Simulation")

        # Oppretter tegneflate for nettverkstegning
        self.canvas = tk.Canvas(root, width=800, height=600)
        self.canvas.pack()

        # Tegner nettverkskomponenter
        self.draw_network()

    def draw_network(self):
        """
        Tegner komponenter og kobler dem sammen.
        """
        # Router
        self.canvas.create_rectangle(50, 250, 150, 350, fill="lightblue", outline="black")
        self.canvas.create_text(100, 300, text="Router", font=("Helvetica", 14))

        # Switch
        self.canvas.create_oval(200, 200, 300, 300, fill="lightgreen", outline="black")
        self.canvas.create_text(250, 250, text="Switch", font=("Helvetica", 14))

        # Server
        self.canvas.create_rectangle(350, 100, 450, 200, fill="lightcoral", outline="black")
        self.canvas.create_text(400, 150, text="Server", font=("Helvetica", 14))

        # Workstation 1
        self.canvas.create_rectangle(350, 300, 450, 400, fill="lightyellow", outline="black")
        self.canvas.create_text(400, 350, text="Workstation 1", font=("Helvetica", 14))

        # Workstation 2
        self.canvas.create_rectangle(500, 300, 600, 400, fill="lightyellow", outline="black")
        self.canvas.create_text(550, 350, text="Workstation 2", font=("Helvetica", 14))

        # Koble sammen komponenter
        self.canvas.create_line(150, 300, 200, 250, width=2)  # Router til Switch
        self.canvas.create_line(300, 250, 350, 150, width=2)  # Switch til Server
        self.canvas.create_line(300, 250, 350, 350, width=2)  # Switch til Workstation 1
        self.canvas

.create_line(450, 350, 500, 350, width=2)  # Workstation 1 til Workstation 2

# Hovedscriptet
if __name__ == "__main__":
    root = tk.Tk()
    app = NetworkSimulationGUI(root)
    root.mainloop()

Forklaring:

  • draw_network: Utvidet for å inkludere flere nettverkskomponenter (f.eks. flere arbeidsstasjoner).
  • GUI: Opprettelse av et grafisk brukergrensesnitt for å visualisere en enkel nettverkstopologi med tkinter.

5. Datasikkerhet og Kryptering - Utvidet med RSA Kryptering

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import serialization, hashes

def generate_rsa_keypair():
    """
    Genererer et RSA nøkkelpar (privat og offentlig nøkkel).
    """
    private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=2048
    )
    public_key = private_key.public_key()
    return private_key, public_key

def encrypt_data_rsa(data, public_key):
    """
    Krypterer data med RSA og offentlig nøkkel.
    """
    encrypted = public_key.encrypt(
        data,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )
    return encrypted

def decrypt_data_rsa(encrypted_data, private_key):
    """
    Dekrypterer data med RSA og privat nøkkel.
    """
    decrypted = private_key.decrypt(
        encrypted_data,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )
    return decrypted

def main():
    # Generer RSA nøkkelpar
    private_key, public_key = generate_rsa_keypair()
    print("RSA keys generated.")

    # Krypter en melding
    message = b"This is a secret message."
    encrypted_message = encrypt_data_rsa(message, public_key)
    print(f"Encrypted Message: {encrypted_message}")

    # Dekrypter meldingen
    decrypted_message = decrypt_data_rsa(encrypted_message, private_key)
    print(f"Decrypted Message: {decrypted_message.decode()}")

if __name__ == "__main__":
    main()

Forklaring:

  • RSA Kryptering: RSA brukes til asymmetrisk kryptering, hvor en offentlig nøkkel krypterer data, og en privat nøkkel dekrypterer dem.
  • generate_rsa_keypair: Genererer et nøkkelpar for kryptering og dekryptering.
  • encrypt_data_rsa / decrypt_data_rsa: Krypterer og dekrypterer meldinger med RSA.

6. Protokoller og API-integrasjon - Utvidet med Autentisering og Feilhåndtering

import requests
import json

def send_data_to_iot_hub(device_id, data, api_key):
    """
    Sender data til en IoT-hub med autentisering.
    """
    url = f"https://your-iot-hub.azure-devices.net/devices/{device_id}/messages/events?api-version=2018-06-30"
    
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    try:
        response = requests.post(url, json=data, headers=headers)
        response.raise_for_status()  # Hever feil hvis statuskoden indikerer feil
        print("Data sent successfully!")
    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP error occurred: {http_err}")
    except Exception as err:
        print(f"An error occurred: {err}")

def main():
    device_id = "MyIoTDevice"
    api_key = "your_api_key_here"
    data = {
        "temperature": 22.5,
        "humidity": 60
    }
    
    send_data_to_iot_hub(device_id, data, api_key)

if __name__ == "__main__":
    main()

Forklaring:

  • Autentisering: API-kall er utvidet til å inkludere API-nøkler for autentisering.
  • Feilhåndtering: Bruker try-except for å håndtere feil under dataoverføring.

7. Virtualisering og Sikkerhet i Hypervisorer - Utvidet med Alarmfunksjoner

import psutil
import smtplib
from email.mime.text import MIMEText

def monitor_virtual_machines():
    """
    Overvåker ressursbruken til virtuelle maskiner og sender alarmer om nødvendig.
    """
    for vm in psutil.virtual_memory():
        cpu_usage = vm.cpu_percent()
        memory_usage = vm.memory_percent()

        print(f"Virtual Machine: {vm.name}")
        print(f"  CPU Usage: {cpu_usage}%")
        print(f"  Memory Usage: {memory_usage}%\n")

        # Sjekk om bruk overstiger terskelverdier
        if cpu_usage > 80 or memory_usage > 80:
            send_alarm_email(vm.name, cpu_usage, memory_usage)

def send_alarm_email(vm_name, cpu_usage, memory_usage):
    """
    Sender en e-postalarm hvis ressursbruken er for høy.
    """
    msg = MIMEText(f"Warning! {vm_name} is using {cpu_usage}% CPU and {memory_usage}% memory.")
    msg['Subject'] = f"High Resource Usage Alert for {vm_name}"
    msg['From'] = "[email protected]"
    msg['To'] = "[email protected]"

    try:
        server = smtplib.SMTP('smtp.yourcompany.com')
        server.sendmail("[email protected]", ["[email protected]"], msg.as_string())
        server.quit()
        print("Alert email sent.")
    except Exception as e:
        print(f"Failed to send alert email: {e}")

def main():
    print("Monitoring Virtual Machines on Hypervisor...\n")
    monitor_virtual_machines()

if __name__ == "__main__":
    main()

Forklaring:

  • Alarmfunksjoner: Skriptet overvåker ressursbruk og sender en alarm via e-post hvis ressursbruken overstiger en terskelverdi.
  • send_alarm_email: Sender en alarmmelding hvis en virtuell maskin bruker for mye ressurser.

8. SQL for Databasesystemer og Backup - Utvidet med Brukeradministrasjon

import sqlite3
from datetime import datetime

def backup_database(db_name, backup_dir):
    """
    Sikkerhetskopierer en SQLite-database til en fil.
    """
    conn = sqlite3.connect(db_name)
    backup_name = f"{backup_dir}/backup_{datetime.now().strftime('%Y%m%d%H%M%S')}.db"
    
    with open(backup_name, 'w') as backup_file:
        for line in conn.iterdump():
            backup_file.write('%s\n' % line)
    
    print(f"Backup created: {backup_name}")
    conn.close()

def create_user(db_name, username, password):
    """
    Oppretter en ny bruker i en SQLite-database.
    """
    conn = sqlite3.connect(db_name)
    cursor = conn.cursor()

    # Oppretter brukertabellen hvis den ikke eksisterer
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        username TEXT UNIQUE,
        password TEXT
    )
    ''')
    
    # Legger til brukeren
    cursor.execute("INSERT INTO users (username, password) VALUES (?, ?)", (username, password))
    conn.commit()
    print(f"User {username} created.")
    conn.close()

def main():
    db_name = "example.db"
    backup_dir = "backups"
    
    # Oppretter en bruker og deretter en sikkerhetskopi
    create_user(db_name, "newuser", "password123")
    backup_database(db_name, backup_dir)

if __name__ == "__main__":
    main()

Forklaring:

  • Brukeradministrasjon: Utvidet for å inkludere opprettelse av brukere i databasen.
  • create_user: Oppretter en ny bruker i en SQLite-database og håndterer unike brukernavn.

9. Automation in Linux System Administration - Utvidet med Sikkerhetsoppdateringer

import subprocess

def create_user(username):
    """
    Oppretter en ny bruker på en Linux-server.
    """
    try:
        subprocess.run(['sudo', 'adduser', username], check=True)
        print(f"User {username} created successfully.")
    except subprocess.CalledProcessError:
        print(f"Failed to create user {username}.")

def delete_user(username):
    """
    Sletter en bruker fra en Linux-server.
    """
    try:
        subprocess.run(['sudo', 'deluser', '--remove-home', username], check=True)
        print(f"User {username} deleted successfully.")
    except subprocess.CalledProcessError:
        print(f"Failed to delete user {username}.")

def update_system():
    """
    Utfører en sikkerhetsoppdatering av systemet.
    """


    try:
        subprocess.run(['sudo', 'apt-get', 'update'], check=True)
        subprocess.run(['sudo', 'apt-get', 'upgrade', '-y'], check=True)
        print("System updated successfully.")
    except subprocess.CalledProcessError:
        print("Failed to update the system.")

def main():
    while True:
        action = input("Enter 'create', 'delete' for user or 'update' to update system: ").strip().lower()
        if action in ['create', 'delete']:
            username = input("Enter username: ").strip()
            if action == 'create':
                create_user(username)
            elif action == 'delete':
                delete_user(username)
        elif action == 'update':
            update_system()
        else:
            print("Invalid action.")

if __name__ == "__main__":
    main()

Forklaring:

  • Systemoppdateringer: Scriptet er utvidet til å inkludere systemoppdateringer som en del av administrasjonsoppgaver.
  • update_system: Kjør sikkerhetsoppdateringer på systemet.

10. Automated Security Audits - Utvidet med Sårbarhetsskanning

import subprocess

def check_firewall_status():
    """
    Sjekker status på brannmur (UFW).
    """
    result = subprocess.run(['sudo', 'ufw', 'status'], capture_output=True, text=True)
    print("Firewall Status:\n", result.stdout)

def check_failed_logins():
    """
    Sjekker mislykkede påloggingsforsøk fra auth.log.
    """
    result = subprocess.run(['sudo', 'grep', 'Failed password', '/var/log/auth.log'], capture_output=True, text=True)
    print("Failed Login Attempts:\n", result.stdout)

def vulnerability_scan():
    """
    Kjør en sårbarhetsskanning med et verktøy som 'Lynis'.
    """
    try:
        result = subprocess.run(['sudo', 'lynis', 'audit', 'system'], capture_output=True, text=True)
        print("Vulnerability Scan Result:\n", result.stdout)
    except FileNotFoundError:
        print("Lynis is not installed. Please install it first.")

def main():
    print("Running Security Audit...\n")
    
    check_firewall_status()
    check_failed_logins()
    vulnerability_scan()

    print("Security Audit Completed.")

if __name__ == "__main__":
    main()

Forklaring:

  • Sårbarhetsskanning: Scriptet er utvidet til å inkludere en enkel sårbarhetsskanning ved hjelp av Lynis.
  • vulnerability_scan: Utfører systemrevisjon og sjekker etter sikkerhetshull.

Oppsummering

Disse utvidede skriptene dekker nå et bredt spekter av emner innenfor programmering og IT-drift, og de er kommentert linje-for-linje for å hjelpe deg med å forstå og tolke koden. Hvert skript bygger på de grunnleggende prinsippene i programmering, fra datastrukturer og funksjoner til objekter og GUI-utvikling, samtidig som de integrerer mer avanserte konsepter som kryptering, API-integrasjon, og automatiserte sikkerhetsrevisjoner. Dette gir en omfattende læringsopplevelse som oppfyller læringsmålene i kurset ditt.

Her er eksempler på hvordan de samme skriptene kan skrives om i både Bash og PowerShell. Jeg vil vise hvordan vi kan implementere tilsvarende funksjonalitet i begge språk, med tilhørende kommentarer for å forklare koden.

1. Grunnleggende Sikkerhetsprinsipper - Hashing Skript

Bash

#!/bin/bash

# Generer en salt-verdi
generate_salt() {
    head -c 16 /dev/urandom | base64
}

# Hash et passord med SHA-256 og salt
hash_password() {
    local password=$1
    local salt=$2
    echo -n "$salt$password" | sha256sum | awk '{print $1}'
}

# Sjekk om passordet matcher hash
check_password() {
    local stored_hash=$1
    local provided_password=$2
    local salt=$3
    local hash=$(hash_password "$provided_password" "$salt")
    [ "$stored_hash" == "$hash" ]
}

# Hovedskript
main() {
    echo "Welcome to Secure Password Storage!"
    read -p "Enter a password to store: " password

    salt=$(generate_salt)
    stored_hash=$(hash_password "$password" "$salt")

    echo "Your hashed password is: $stored_hash"

    read -p "Re-enter your password to check: " test_password
    if check_password "$stored_hash" "$test_password" "$salt"; then
        echo "Password matched!"
    else
        echo "Password did not match!"
    fi
}

main

PowerShell

# Generer en salt-verdi
function Generate-Salt {
    $saltBytes = New-Object byte[] 16
    [System.Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($saltBytes)
    return [Convert]::ToBase64String($saltBytes)
}

# Hash et passord med SHA-256 og salt
function Hash-Password {
    param (
        [string]$password,
        [string]$salt
    )
    $combined = $salt + $password
    $sha256 = [System.Security.Cryptography.SHA256]::Create()
    $hash = $sha256.ComputeHash([System.Text.Encoding]::UTF8.GetBytes($combined))
    return [BitConverter]::ToString($hash) -replace '-', ''
}

# Sjekk om passordet matcher hash
function Check-Password {
    param (
        [string]$storedHash,
        [string]$providedPassword,
        [string]$salt
    )
    $hash = Hash-Password -password $providedPassword -salt $salt
    return $storedHash -eq $hash
}

# Hovedskript
function Main {
    Write-Host "Welcome to Secure Password Storage!"
    $password = Read-Host "Enter a password to store"

    $salt = Generate-Salt
    $storedHash = Hash-Password -password $password -salt $salt

    Write-Host "Your hashed password is: $storedHash"

    $testPassword = Read-Host "Re-enter your password to check"
    if (Check-Password -storedHash $storedHash -providedPassword $testPassword -salt $salt) {
        Write-Host "Password matched!"
    }
    else {
        Write-Host "Password did not match!"
    }
}

Main

2. Objektorientert Programmering og IoT Enhetssimulering

Bash

Bash har ikke innebygd støtte for objektorientert programmering som Python. Derfor bruker vi funksjoner og assosiative arrays for å simulere OOP.

#!/bin/bash

# Simulerer en IoT-enhet ved hjelp av funksjoner og arrays

declare -A IoTDevice

# Initialiserer en IoT-enhet
IoTDevice_Init() {
    IoTDevice[name]=$1
    IoTDevice[type]=$2
}

# Generer tilfeldig data
IoTDevice_GenerateData() {
    case ${IoTDevice[type]} in
        "Temperature Sensor") IoTDevice[data]=$(echo "scale=2; 20 + $RANDOM % 10" | bc) ;;
        "Humidity Sensor") IoTDevice[data]=$(echo "scale=2; 30 + $RANDOM % 40" | bc) ;;
        "Pressure Sensor") IoTDevice[data]=$(echo "scale=2; 950 + $RANDOM % 100" | bc) ;;
    esac
    IoTDevice[timestamp]=$(date --iso-8601=seconds)
}

# Send data til API (simulert)
IoTDevice_SendData() {
    local api_url=$1
    echo "Sending data to $api_url..."
    echo "Device: ${IoTDevice[name]}"
    echo "Type: ${IoTDevice[type]}"
    echo "Data: ${IoTDevice[data]}"
    echo "Timestamp: ${IoTDevice[timestamp]}"
}

# Hovedskript
main() {
    IoTDevice_Init "TempSensor1" "Temperature Sensor"
    IoTDevice_GenerateData
    IoTDevice_SendData "http://example.com/api/data"
}

main

PowerShell

PowerShell har støtte for objektorientert programmering, så vi kan opprette klasser direkte.

class IoTDevice {
    [string]$Name
    [string]$DeviceType
    [float]$Data
    [string]$Timestamp

    IoTDevice([string]$name, [string]$deviceType) {
        $this.Name = $name
        $this.DeviceType = $deviceType
    }

    [void]GenerateData() {
        switch ($this.DeviceType) {
            "Temperature Sensor" { $this.Data = Get-Random -Minimum 20.0 -Maximum 30.0 }
            "Humidity Sensor" { $this.Data = Get-Random -Minimum 30.0 -Maximum 70.0 }
            "Pressure Sensor" { $this.Data = Get-Random -Minimum 950.0 -Maximum 1050.0 }
        }
        $this.Timestamp = Get-Date -Format "yyyy-MM-ddTHH:mm:ss"
    }

    [void]SendData([string]$apiUrl) {
        Write-Host "Sending data to $apiUrl..."
        Write-Host "Device: $($this.Name)"
        Write-Host "Type: $($this.DeviceType)"
        Write-Host "Data: $($this.Data)"
        Write-Host "Timestamp: $($this.Timestamp)"
    }
}

# Hovedskript
function Main {
    $sensor = [IoTDevice]::new("TempSensor1", "Temperature Sensor")
    $sensor.GenerateData()
    $sensor.SendData("http://example.com/api/data")
}

Main

3. Filbehandling og Logging for Servervedlikehold

Bash

#!/bin/bash

LOG_DB="server_log.db"

# Oppretter SQLite-tabell for logging hvis den ikke finnes
sqlite3 $LOG_DB "CREATE TABLE IF NOT EXISTS logs (id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp TEXT, event TEXT);"

# Logger en hendelse til SQLite
log_event() {
    local event=$1
    local timestamp=$(date --iso-8601=seconds)
    sqlite3 $LOG_DB "INSERT INTO logs (timestamp, event) VALUES ('$timestamp', '$event');"
}

# Leser loggene fra SQLite-databasen
read_logs() {
    sqlite3 $LOG_DB "SELECT * FROM logs;"
}

# Hovedskript
main() {
    echo "Server Maintenance Log"
    
    # Logger en hendelse
    log_event "System backup completed successfully."
    
    # Leser loggene
    read_logs
}

main

PowerShell

$logDB = "server_log.db"

# Oppretter SQLite-tabell for logging hvis den ikke finnes
if (-not (Test-Path $logDB)) {
    $conn = New-Object System.Data.SQLite.SQLiteConnection
    $conn.ConnectionString = "Data Source=$logDB;Version=3;"
    $conn.Open()
    $cmd = $conn.CreateCommand()
    $cmd.CommandText = "CREATE TABLE IF NOT EXISTS logs (id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp TEXT, event TEXT);"
    $cmd.ExecuteNonQuery()
    $conn.Close()
}

# Logger en hendelse til SQLite
function Log-Event {
    param (
        [string]$event
    )
    $timestamp = (Get-Date).ToString("yyyy-MM-ddTHH:mm:ss")
    $conn = New-Object System.Data.SQLite.SQLiteConnection
    $conn.ConnectionString = "Data Source=$logDB;Version=3;"
    $conn.Open()
    $cmd = $conn.CreateCommand()
    $cmd.CommandText = "INSERT INTO logs (timestamp, event) VALUES ('$timestamp', '$event');"
    $cmd.ExecuteNonQuery()
    $conn.Close()
}

# Leser loggene fra SQLite-databasen
function Read-Logs {
    $conn = New-Object System.Data.SQLite.SQLiteConnection
    $conn.ConnectionString = "Data Source=$logDB;Version=3;"
    $conn.Open()
    $cmd = $conn.CreateCommand()
    $cmd.CommandText = "SELECT * FROM logs;"
    $reader = $cmd.ExecuteReader()
    while ($reader.Read()) {
        Write-Host "ID: $($reader['id']) Timestamp: $($reader['timestamp']) Event: $($reader['event'])"
    }
    $conn.Close

()
}

# Hovedskript
function Main {
    Write-Host "Server Maintenance Log"
    
    # Logger en hendelse
    Log-Event "System backup completed successfully."
    
    # Leser loggene
    Read-Logs
}

Main

4. Nettverkstopologier og Simuleringsverktøy med GUI

GUI-utvikling er ikke like vanlig i Bash, men vi kan skrive ut tekstbaserte nettverkstopologier. I PowerShell kan vi lage et enklere GUI.

Bash (tekstbasert)

#!/bin/bash

# Tegn en enkel nettverkstopologi som tekst
echo "Router ------ Switch ------ Server"
echo "              |             "
echo "            Workstation 1 -- Workstation 2"

PowerShell (enkelt GUI)

Add-Type -AssemblyName System.Windows.Forms
Add-Type -AssemblyName System.Drawing

$form = New-Object System.Windows.Forms.Form
$form.Text = "Network Topology Simulation"
$form.Size = New-Object System.Drawing.Size(800, 600)

$canvas = New-Object System.Windows.Forms.Panel
$canvas.Dock = 'Fill'
$canvas.BackColor = [System.Drawing.Color]::White
$form.Controls.Add($canvas)

$graphics = $canvas.CreateGraphics()

# Tegner Router
$graphics.FillRectangle([System.Drawing.Brushes]::LightBlue, 50, 250, 100, 100)
$graphics.DrawString("Router", [System.Drawing.Font]::new("Arial", 12), [System.Drawing.Brushes]::Black, 70, 290)

# Tegner Switch
$graphics.FillEllipse([System.Drawing.Brushes]::LightGreen, 200, 200, 100, 100)
$graphics.DrawString("Switch", [System.Drawing.Font]::new("Arial", 12), [System.Drawing.Brushes]::Black, 230, 240)

# Tegner Server
$graphics.FillRectangle([System.Drawing.Brushes]::LightCoral, 350, 100, 100, 100)
$graphics.DrawString("Server", [System.Drawing.Font]::new("Arial", 12), [System.Drawing.Brushes]::Black, 380, 140)

# Tegner Workstation 1
$graphics.FillRectangle([System.Drawing.Brushes]::LightYellow, 350, 300, 100, 100)
$graphics.DrawString("Workstation 1", [System.Drawing.Font]::new("Arial", 12), [System.Drawing.Brushes]::Black, 355, 340)

# Tegner Workstation 2
$graphics.FillRectangle([System.Drawing.Brushes]::LightYellow, 500, 300, 100, 100)
$graphics.DrawString("Workstation 2", [System.Drawing.Font]::new("Arial", 12), [System.Drawing.Brushes]::Black, 505, 340)

# Kobler sammen komponenter
$graphics.DrawLine([System.Drawing.Pens]::Black, 150, 300, 200, 250)
$graphics.DrawLine([System.Drawing.Pens]::Black, 300, 250, 350, 150)
$graphics.DrawLine([System.Drawing.Pens]::Black, 300, 250, 350, 350)
$graphics.DrawLine([System.Drawing.Pens]::Black, 450, 350, 500, 350)

$form.ShowDialog()

5. Datasikkerhet og Kryptering - RSA Kryptering

Bash (simulert RSA med OpenSSL)

#!/bin/bash

# Generer RSA nøkkelpar
openssl genpkey -algorithm RSA -out private_key.pem
openssl rsa -pubout -in private_key.pem -out public_key.pem

# Krypter en melding
echo "This is a secret message." > message.txt
openssl rsautl -encrypt -inkey public_key.pem -pubin -in message.txt -out encrypted_message.bin

# Dekrypter meldingen
openssl rsautl -decrypt -inkey private_key.pem -in encrypted_message.bin -out decrypted_message.txt

echo "Decrypted Message:"
cat decrypted_message.txt

PowerShell (ekte RSA med .NET)

# Generer RSA nøkkelpar
$RSA = [System.Security.Cryptography.RSA]::Create(2048)

$privateKey = $RSA.ExportRSAPrivateKey()
$publicKey = $RSA.ExportRSAPublicKey()

[System.IO.File]::WriteAllBytes("private_key.bin", $privateKey)
[System.IO.File]::WriteAllBytes("public_key.bin", $publicKey)

# Krypter en melding
$message = [System.Text.Encoding]::UTF8.GetBytes("This is a secret message.")
$encryptedMessage = $RSA.Encrypt($message, [System.Security.Cryptography.RSAEncryptionPadding]::OaepSHA256)
[System.IO.File]::WriteAllBytes("encrypted_message.bin", $encryptedMessage)

# Dekrypter meldingen
$decryptedMessage = $RSA.Decrypt($encryptedMessage, [System.Security.Cryptography.RSAEncryptionPadding]::OaepSHA256)
[System.Text.Encoding]::UTF8.GetString($decryptedMessage)

6. Protokoller og API-integrasjon

Bash

#!/bin/bash

# Send data til et API med autentisering
send_data_to_api() {
    local api_url=$1
    local api_key=$2
    local data=$3

    curl -X POST "$api_url" \
         -H "Authorization: Bearer $api_key" \
         -H "Content-Type: application/json" \
         -d "$data"
}

# Hovedskript
main() {
    local api_url="https://your-iot-hub.azure-devices.net/devices/MyIoTDevice/messages/events?api-version=2018-06-30"
    local api_key="your_api_key_here"
    local data='{"temperature":22.5,"humidity":60}'

    send_data_to_api "$api_url" "$api_key" "$data"
}

main

PowerShell

# Send data til et API med autentisering
function Send-DataToApi {
    param (
        [string]$apiUrl,
        [string]$apiKey,
        [hashtable]$data
    )

    $jsonData = $data | ConvertTo-Json
    $headers = @{
        "Authorization" = "Bearer $apiKey"
        "Content-Type"  = "application/json"
    }

    Invoke-RestMethod -Uri $apiUrl -Method Post -Headers $headers -Body $jsonData
}

# Hovedskript
function Main {
    $apiUrl = "https://your-iot-hub.azure-devices.net/devices/MyIoTDevice/messages/events?api-version=2018-06-30"
    $apiKey = "your_api_key_here"
    $data = @{
        temperature = 22.5
        humidity = 60
    }

    Send-DataToApi -apiUrl $apiUrl -apiKey $apiKey -data $data
}

Main

7. Virtualisering og Sikkerhet i Hypervisorer

Bash

#!/bin/bash

# Overvåker ressursbruken til virtuelle maskiner
monitor_vms() {
    local cpu_usage=$(ps aux --sort=-%cpu | head -n 5)
    local mem_usage=$(ps aux --sort=-%mem | head -n 5)

    echo "CPU Usage:"
    echo "$cpu_usage"
    echo ""
    echo "Memory Usage:"
    echo "$mem_usage"
}

# Sende e-post alarm
send_alarm_email() {
    local vm_name=$1
    local cpu_usage=$2
    local mem_usage=$3

    echo "Warning! $vm_name is using $cpu_usage% CPU and $mem_usage% memory." | mail -s "High Resource Usage Alert for $vm_name" [email protected]
}

# Hovedskript
main() {
    monitor_vms
    # Eksempel på alarm hvis CPU-bruken overstiger 80% (kan justeres)
    if [ $(ps aux --sort=-%cpu | awk 'NR==2 {print $3}') > 80 ]; then
        send_alarm_email "ExampleVM" 85 70
    fi
}

main

PowerShell

# Overvåker ressursbruken til virtuelle maskiner
function Monitor-VirtualMachines {
    $vms = Get-Process | Sort-Object CPU -Descending | Select-Object -First 5
    foreach ($vm in $vms) {
        Write-Host "Process: $($vm.Name)"
        Write-Host "  CPU Usage: $($vm.CPU)%"
        Write-Host "  Memory Usage: $([math]::Round($vm.WorkingSet / 1MB, 2)) MB"
        Write-Host ""
        
        if ($vm.CPU -gt 80) {
            Send-AlarmEmail -vmName $vm.Name -cpuUsage $vm.CPU -memoryUsage $([math]::Round($vm.WorkingSet / 1MB, 2))
        }
    }
}

# Sende e-post alarm
function Send-AlarmEmail {
    param (
        [string]$vmName,
        [float]$cpuUsage,
        [float]$memoryUsage
    )

    $smtpServer = "smtp.yourcompany.com

"
    $message = "Warning! $vmName is using $cpuUsage% CPU and $memoryUsage MB memory."
    $subject = "High Resource Usage Alert for $vmName"
    $from = "[email protected]"
    $to = "[email protected]"

    $mailMessage = New-Object system.net.mail.mailmessage
    $mailMessage.From = $from
    $mailMessage.To.Add($to)
    $mailMessage.Subject = $subject
    $mailMessage.Body = $message

    $smtp = New-Object Net.Mail.SmtpClient($smtpServer)
    $smtp.Send($mailMessage)

    Write-Host "Alert email sent."
}

# Hovedskript
function Main {
    Monitor-VirtualMachines
}

Main

8. SQL for Databasesystemer og Backup

Bash

#!/bin/bash

DB_NAME="example.db"
BACKUP_DIR="backups"

# Sikkerhetskopier database
backup_database() {
    local timestamp=$(date +"%Y%m%d%H%M%S")
    sqlite3 $DB_NAME ".backup '$BACKUP_DIR/backup_$timestamp.db'"
    echo "Backup created: backup_$timestamp.db"
}

# Opprett bruker
create_user() {
    local username=$1
    local password=$2
    sqlite3 $DB_NAME "INSERT INTO users (username, password) VALUES ('$username', '$password');"
    echo "User $username created."
}

# Hovedskript
main() {
    mkdir -p $BACKUP_DIR
    
    # Oppretter brukertabellen hvis den ikke finnes
    sqlite3 $DB_NAME "CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY AUTOINCREMENT, username TEXT UNIQUE, password TEXT);"
    
    # Opprett bruker og lag backup
    create_user "newuser" "password123"
    backup_database
}

main

PowerShell

$DBName = "example.db"
$BackupDir = "backups"

# Sikkerhetskopier database
function Backup-Database {
    $timestamp = (Get-Date).ToString("yyyyMMddHHmmss")
    $backupName = Join-Path $BackupDir "backup_$timestamp.db"

    $conn = New-Object System.Data.SQLite.SQLiteConnection
    $conn.ConnectionString = "Data Source=$DBName;Version=3;"
    $conn.Open()
    $cmd = $conn.CreateCommand()
    $cmd.CommandText = "BACKUP TO '$backupName';"
    $cmd.ExecuteNonQuery()
    $conn.Close()

    Write-Host "Backup created: $backupName"
}

# Opprett bruker
function Create-User {
    param (
        [string]$username,
        [string]$password
    )

    $conn = New-Object System.Data.SQLite.SQLiteConnection
    $conn.ConnectionString = "Data Source=$DBName;Version=3;"
    $conn.Open()

    $cmd = $conn.CreateCommand()
    $cmd.CommandText = "INSERT INTO users (username, password) VALUES ('$username', '$password');"
    $cmd.ExecuteNonQuery()

    $conn.Close()

    Write-Host "User $username created."
}

# Hovedskript
function Main {
    if (-not (Test-Path $BackupDir)) {
        New-Item -ItemType Directory -Path $BackupDir
    }
    
    # Opprett brukertabellen hvis den ikke finnes
    $conn = New-Object System.Data.SQLite.SQLiteConnection
    $conn.ConnectionString = "Data Source=$DBName;Version=3;"
    $conn.Open()

    $cmd = $conn.CreateCommand()
    $cmd.CommandText = "CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY AUTOINCREMENT, username TEXT UNIQUE, password TEXT);"
    $cmd.ExecuteNonQuery()

    $conn.Close()

    # Opprett bruker og lag backup
    Create-User -username "newuser" -password "password123"
    Backup-Database
}

Main

9. Automation in Linux System Administration

Bash

#!/bin/bash

# Opprett bruker
create_user() {
    local username=$1
    sudo adduser $username
}

# Slett bruker
delete_user() {
    local username=$1
    sudo deluser --remove-home $username
}

# Oppdater system
update_system() {
    sudo apt-get update
    sudo apt-get upgrade -y
}

# Hovedskript
main() {
    echo "Enter 'create', 'delete' for user or 'update' to update system:"
    read action
    
    if [ "$action" == "create" ] || [ "$action" == "delete" ]; then
        echo "Enter username:"
        read username
        
        if [ "$action" == "create" ]; then
            create_user "$username"
        elif [ "$action" == "delete" ]; then
            delete_user "$username"
        fi
    elif [ "$action" == "update" ]; then
        update_system
    else
        echo "Invalid action."
    fi
}

main

PowerShell

# Opprett bruker
function Create-User {
    param (
        [string]$username
    )
    Start-Process "net" "user $username /add" -NoNewWindow -Wait
    Write-Host "User $username created successfully."
}

# Slett bruker
function Delete-User {
    param (
        [string]$username
    )
    Start-Process "net" "user $username /delete" -NoNewWindow -Wait
    Write-Host "User $username deleted successfully."
}

# Oppdater system (Windows Update)
function Update-System {
    Start-Process "powershell" "-Command Get-WindowsUpdate -Install" -NoNewWindow -Wait
    Write-Host "System updated successfully."
}

# Hovedskript
function Main {
    $action = Read-Host "Enter 'create', 'delete' for user or 'update' to update system"

    if ($action -eq "create" -or $action -eq "delete") {
        $username = Read-Host "Enter username"
        
        if ($action -eq "create") {
            Create-User -username $username
        }
        elseif ($action -eq "delete") {
            Delete-User -username $username
        }
    }
    elseif ($action -eq "update") {
        Update-System
    }
    else {
        Write-Host "Invalid action."
    }
}

Main

10. Automated Security Audits

Bash

#!/bin/bash

# Sjekk brannmurstatus (UFW)
check_firewall_status() {
    sudo ufw status
}

# Sjekk mislykkede påloggingsforsøk
check_failed_logins() {
    sudo grep 'Failed password' /var/log/auth.log
}

# Sårbarhetsskanning med Lynis
vulnerability_scan() {
    sudo lynis audit system
}

# Hovedskript
main() {
    echo "Running Security Audit..."
    check_firewall_status
    check_failed_logins
    vulnerability_scan
    echo "Security Audit Completed."
}

main

PowerShell

# Sjekk brannmurstatus (Windows Firewall)
function Check-FirewallStatus {
    Get-NetFirewallProfile | Select-Object Name, Enabled
}

# Sjekk mislykkede påloggingsforsøk
function Check-FailedLogins {
    Get-EventLog -LogName Security -InstanceId 4625 | Select-Object TimeGenerated, Message
}

# Sårbarhetsskanning med sfc (System File Checker)
function Vulnerability-Scan {
    sfc /scannow
}

# Hovedskript
function Main {
    Write-Host "Running Security Audit..."
    Check-FirewallStatus
    Check-FailedLogins
    Vulnerability-Scan
    Write-Host "Security Audit Completed."
}

Main

Oppsummering

Disse skriptene demonstrerer hvordan man kan implementere lignende funksjoner som de Python-skriptene, men ved å bruke Bash og PowerShell. Hvert skript er utformet for å være så likt som mulig Python-eksemplene, med hensyn til språkets spesifikasjoner og muligheter.

Disse eksemplene dekker en rekke ulike emner innen IT-drift og programmering, inkludert sikkerhet, nettverk, filbehandling, databaser, automatisering, og mer. Hver funksjon er kommentert for å forklare formålet med koden, og hvordan den kan tilpasses til dine behov.