In der Cybersicherheit ist ein Honeypot ein Ablenkungssystem, das darauf ausgelegt ist, potenzielle Angreifer anzulocken und dann zu erkennen, die versuchen, das System zu kompromittieren. Genau wie ein Topf mit Honig, der offen steht, Fliegen anziehen würde.

Denken Sie an diese Honeypots als Sicherheitskameras für Ihr System. So wie eine Sicherheitskamera uns hilft zu verstehen, wer versucht, in ein Gebäude einzubrechen und wie sie es tun, werden Ihnen diese Honeypots helfen zu verstehen, wer versucht, Ihr System anzugreifen und welche Techniken sie verwenden.

Am Ende dieses Tutorials werden Sie in der Lage sein, einen Demo-Honeypot in Python zu schreiben und zu verstehen, wie Honeypots funktionieren.

Inhaltsverzeichnis

Verstehen der Arten von Honeypots

Bevor wir mit dem Design unseres eigenen Honeypots beginnen, lassen Sie uns schnell die verschiedenen Typen verstehen:

  1. Produktions-Honeypots: Diese Arten von Honeypots werden in einer tatsächlichen Produktionsumgebung platziert und dienen dazu, tatsächliche Sicherheitsangriffe zu erkennen. Sie sind typischerweise einfach im Design, leicht zu warten und bereitzustellen, und bieten eine eingeschränkte Interaktion, um das Risiko zu reduzieren.

  2. Forschungs-Honeypots: Dies sind komplexere Systeme, die von Sicherheitsforschern eingerichtet werden, um Angriffsarten zu studieren, empirische Analysen zu diesen Mustern durchzuführen, Malware-Proben zu sammeln und neue Angriffstechniken zu verstehen, die zuvor nicht entdeckt wurden. Sie emulieren oft gesamte Betriebssysteme oder Netzwerke, anstatt sich wie eine Anwendung in der Produktionsumgebung zu verhalten.

Für dieses Tutorial werden wir einen Honeypot mit mittlerer Interaktion erstellen, der Verbindungsversuche und grundlegendes Angreiferverhalten protokolliert.

So richten Sie Ihre Entwicklungsumgebung ein

Beginnen wir mit der Einrichtung Ihrer Entwicklungsumgebung in Python. Führen Sie die folgenden Befehle aus:

import socket
import sys
import datetime
import json
import threading
from pathlib import Path

# Konfigurieren Sie das Protokollverzeichnis
LOG_DIR = Path("honeypot_logs")
LOG_DIR.mkdir(exist_ok=True)

Wir werden bei den integrierten Bibliotheken bleiben, sodass wir keine externen Abhängigkeiten installieren müssen. Wir speichern unsere Protokolle im Verzeichnis honeypot_logs.

So bauen Sie den Kern-Honeypot

Unser grundlegender Honeypot wird aus drei Komponenten bestehen:

  1. Ein Netzwerklistener, der Verbindungen akzeptiert

  2. Ein Protokollsystem zur Aufzeichnung von Aktivitäten

  3. Ein grundlegender Emulationsdienst zur Interaktion mit Angreifern

Nun lassen Sie uns damit beginnen, die Kern-Honeypot-Klasse zu initialisieren:

class Honeypot:
    def __init__(self, bind_ip="0.0.0.0", ports=None):
        self.bind_ip = bind_ip
        self.ports = ports or [21, 22, 80, 443]  # Standardports zur Überwachung
        self.active_connections = {}
        self.log_file = LOG_DIR / f"honeypot_{datetime.datetime.now().strftime('%Y%m%d')}.json"

    def log_activity(self, port, remote_ip, data):
        """Log suspicious activity with timestamp and details"""
        activity = {
            "timestamp": datetime.datetime.now().isoformat(),
            "remote_ip": remote_ip,
            "port": port,
            "data": data.decode('utf-8', errors='ignore')
        }

        with open(self.log_file, 'a') as f:
            json.dump(activity, f)
            f.write('\n')

    def handle_connection(self, client_socket, remote_ip, port):
        """Handle individual connections and emulate services"""
        service_banners = {
            21: "220 FTP server ready\r\n",
            22: "SSH-2.0-OpenSSH_8.2p1 Ubuntu-4ubuntu0.1\r\n",
            80: "HTTP/1.1 200 OK\r\nServer: Apache/2.4.41 (Ubuntu)\r\n\r\n",
            443: "HTTP/1.1 200 OK\r\nServer: Apache/2.4.41 (Ubuntu)\r\n\r\n"
        }

        try:
            # Sende das entsprechende Banner für den Dienst
            if port in service_banners:
                client_socket.send(service_banners[port].encode())

            # Empfange Daten vom Angreifer
            while True:
                data = client_socket.recv(1024)
                if not data:
                    break

                self.log_activity(port, remote_ip, data)

                # Sende gefälschte Antwort
                client_socket.send(b"Command not recognized.\r\n")

        except Exception as e:
            print(f"Error handling connection: {e}")
        finally:
            client_socket.close()

Diese Klasse enthält viele wichtige Informationen, also gehen wir jede Funktion einzeln durch.

Die __init__-Funktion zeichnet die IP- und Portnummern auf, auf denen wir den Honeypot hosten werden, sowie den Pfad / Dateinamen der Protokolldatei. Wir werden auch eine Aufzeichnung der Gesamtzahl aktiver Verbindungen zu dem Honeypot führen.

Die log_activity-Funktion wird Informationen über die IP, die Daten und den Port, zu dem die IP eine Verbindung versucht hat, empfangen. Dann werden wir diese Informationen in unsere im JSON-Format gehaltene Protokolldatei einfügen.

Die handle_connection-Funktion wird diese Dienste nachahmen, die auf den verschiedenen Ports, die wir haben, laufen werden. Wir werden den Honeypot auf den Ports 21, 22, 80 und 443 betreiben. Diese Dienste sind für FTP, SSH, HTTP und das HTTPS-Protokoll vorgesehen. Jeder Angreifer, der versucht, mit dem Honeypot zu interagieren, sollte diese Dienste auf diesen Ports erwarten.

Um das Verhalten dieser Dienste nachzuahmen, werden wir die Dienstbanner verwenden, die sie in der Realität nutzen. Diese Funktion wird zunächst das entsprechende Banner senden, wenn der Angreifer sich verbindet, und dann die Daten empfangen und protokollieren. Der Honeypot wird auch eine gefälschte Antwort „Befehl nicht erkannt“ an den Angreifer zurücksenden.

Implementiere die Netzwerk-Listener

Jetzt implementieren wir die Netzwerk-Listener, die die eingehenden Verbindungen bearbeiten werden. Dazu werden wir einfache Socket-Programmierung verwenden. Wenn du nicht weißt, wie Socket-Programmierung funktioniert, sieh dir diesen Artikel an, der einige Konzepte dazu erklärt.

def start_listener(self, port):
    """Start a listener on specified port"""
    try:
        server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server.bind((self.bind_ip, port))
        server.listen(5)

        print(f"[*] Listening on {self.bind_ip}:{port}")

        while True:
            client, addr = server.accept()
            print(f"[*] Accepted connection from {addr[0]}:{addr[1]}")

            # Verbindung in einem separaten Thread bearbeiten
            client_handler = threading.Thread(
                target=self.handle_connection,
                args=(client, addr[0], port)
            )
            client_handler.start()

    except Exception as e:
        print(f"Error starting listener on port {port}: {e}")

Die start_listener-Funktion wird den Server starten und auf dem angegebenen Port lauschen. Die bind_ip für uns wird 0.0.0.0 sein, was bedeutet, dass der Server auf allen Netzwerkschnittstellen lauscht.

Jetzt werden wir jede neue Verbindung in einem separaten Thread bearbeiten, da es Situationen geben könnte, in denen mehrere Angreifer versuchen, mit dem Honeypot zu interagieren oder ein angreifendes Skript oder Tool den Honeypot scannt. Wenn du nicht weißt, wie Threading funktioniert, kannst du dir diesen Artikel ansehen, der Threading und Parallelität in Python erklärt.

Stelle auch sicher, dass du diese Funktion in die Kern-Honeypot-Klasse einfügst.

Honeypot starten

Jetzt lass uns die main-Funktion erstellen, die unseren Honeypot startet.

def main():
    honeypot = Honeypot()

    # Listener für jeden Port in separaten Threads starten
    for port in honeypot.ports:
        listener_thread = threading.Thread(
            target=honeypot.start_listener,
            args=(port,)
        )
        listener_thread.daemon = True
        listener_thread.start()

    try:
        # Hauptthread am Leben halten
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        print("\n[*] Shutting down honeypot...")
        sys.exit(0)

if __name__ == "__main__":
    main()

Diese Funktion instanziiert die Honeypot-Klasse und startet die Listener für jeden unserer definierten Ports (21, 22, 80, 443) als separaten Thread. Jetzt halten wir unseren Hauptthread, der unser tatsächliches Programm ausführt, am Leben, indem wir ihn in einer Endlosschleife belassen. Fasse dies alles in einem Skript zusammen und führe es aus.

Schreibe den Honeypot Angriffssimulator

Jetzt lass uns versuchen, einige Angriffsszenarien zu simulieren und unseren Honeypot anzugreifen, damit wir einige Daten in unserer JSON-Protokolldatei sammeln können.

Dieser Simulator wird uns helfen, einige wichtige Aspekte von Honeypots zu demonstrieren:

  1. Realistische Angriffsmuster: Der Simulator wird gängige Angriffsmuster wie Portscanning, Brute-Force-Versuche und dienstspezifische Exploits simulieren.

  2. Variable Intensität: Der Simulator wird die Intensität der Simulation anpassen, um zu testen, wie Ihr Honeypot mit unterschiedlichen Lasten umgeht.

  3. Mehrere Angriffstypen: Er wird verschiedene Arten von Angriffen demonstrieren, die echte Angreifer versuchen könnten, und Ihnen helfen zu verstehen, wie Ihr Honeypot auf jeden einzelnen reagiert.

  4. Gleichzeitige Verbindungen: Der Simulator wird Multithreading verwenden, um zu testen, wie Ihr Honeypot mit mehreren gleichzeitigen Verbindungen umgeht.

# honeypot_simulator.py

import socket
import time
import random
import threading
from concurrent.futures import ThreadPoolExecutor
import argparse

class HoneypotSimulator:
    """
    A class to simulate different types of connections and attacks against our honeypot.
    This helps in testing the honeypot's logging and response capabilities.
    """

    def __init__(self, target_ip="127.0.0.1", intensity="medium"):
        # Konfiguration für den Simulator
        self.target_ip = target_ip
        self.intensity = intensity

        # Häufige Ports, die von Angreifern oft überprüft werden
        self.target_ports = [21, 22, 23, 25, 80, 443, 3306, 5432]

        # Wörterbuch gängiger Befehle, die von Angreifern für verschiedene Dienste verwendet werden
        self.attack_patterns = {
            21: [  # FTP-Befehle
                "USER admin\r\n",
                "PASS admin123\r\n",
                "LIST\r\n",
                "STOR malware.exe\r\n"
            ],
            22: [  # SSH-Versuche
                "SSH-2.0-OpenSSH_7.9\r\n",
                "admin:password123\n",
                "root:toor\n"
            ],
            80: [  # HTTP-Anfragen
                "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n",
                "POST /admin HTTP/1.1\r\nHost: localhost\r\nContent-Length: 0\r\n\r\n",
                "GET /wp-admin HTTP/1.1\r\nHost: localhost\r\n\r\n"
            ]
        }

        # Intensitätseinstellungen beeinflussen die Häufigkeit und das Volumen der simulierten Angriffe
        self.intensity_settings = {
            "low": {"max_threads": 2, "delay_range": (1, 3)},
            "medium": {"max_threads": 5, "delay_range": (0.5, 1.5)},
            "high": {"max_threads": 10, "delay_range": (0.1, 0.5)}
        }

    def simulate_connection(self, port):
        """
        Simulates a connection attempt to a specific port with realistic attack patterns
        """
        try:
            # Erstellen Sie eine neue Socket-Verbindung
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(3)

            print(f"[*] Attempting connection to {self.target_ip}:{port}")
            sock.connect((self.target_ip, port))

            # Banner abrufen, falls vorhanden
            banner = sock.recv(1024)
            print(f"[+] Received banner from port {port}: {banner.decode('utf-8', 'ignore').strip()}")

            # Angriffs Muster basierend auf dem Port senden
            if port in self.attack_patterns:
                for command in self.attack_patterns[port]:
                    print(f"[*] Sending command to port {port}: {command.strip()}")
                    sock.send(command.encode())

                    # Auf Antwort warten
                    try:
                        response = sock.recv(1024)
                        print(f"[+] Received response: {response.decode('utf-8', 'ignore').strip()}")
                    except socket.timeout:
                        print(f"[-] No response received from port {port}")

                    # Fügen Sie eine realistische Verzögerung zwischen den Befehlen ein
                    time.sleep(random.uniform(*self.intensity_settings[self.intensity]["delay_range"]))

            sock.close()

        except ConnectionRefusedError:
            print(f"[-] Connection refused on port {port}")
        except socket.timeout:
            print(f"[-] Connection timeout on port {port}")
        except Exception as e:
            print(f"[-] Error connecting to port {port}: {e}")

    def simulate_port_scan(self):
        """
        Simulates a basic port scan across common ports
        """
        print(f"\n[*] Starting port scan simulation against {self.target_ip}")
        for port in self.target_ports:
            self.simulate_connection(port)
            time.sleep(random.uniform(0.1, 0.3))

    def simulate_brute_force(self, port):
        """
        Simulates a brute force attack against a specific service
        """
        common_usernames = ["admin", "root", "user", "test"]
        common_passwords = ["password123", "admin123", "123456", "root"]

        print(f"\n[*] Starting brute force simulation against port {port}")

        for username in common_usernames:
            for password in common_passwords:
                try:
                    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                    sock.settimeout(2)
                    sock.connect((self.target_ip, port))

                    if port == 21:  # FTP
                        sock.send(f"USER {username}\r\n".encode())
                        sock.recv(1024)
                        sock.send(f"PASS {password}\r\n".encode())
                    elif port == 22:  # SSH
                        sock.send(f"{username}:{password}\n".encode())

                    sock.close()
                    time.sleep(random.uniform(0.1, 0.3))

                except Exception as e:
                    print(f"[-] Error in brute force attempt: {e}")

    def run_continuous_simulation(self, duration=300):
        """
        Runs a continuous simulation for a specified duration
        """
        print(f"\n[*] Starting continuous simulation for {duration} seconds")
        print(f"[*] Intensity level: {self.intensity}")

        end_time = time.time() + duration

        with ThreadPoolExecutor(
            max_workers=self.intensity_settings[self.intensity]["max_threads"]
        ) as executor:
            while time.time() < end_time:
                # Mischung verschiedener Angriffsmuster
                simulation_choices = [
                    lambda: self.simulate_port_scan(),
                    lambda: self.simulate_brute_force(21),
                    lambda: self.simulate_brute_force(22),
                    lambda: self.simulate_connection(80)
                ]

                # Wählen Sie zufällig ein Angriffsmuster aus und führen Sie es aus
                executor.submit(random.choice(simulation_choices))
                time.sleep(random.uniform(*self.intensity_settings[self.intensity]["delay_range"]))

def main():
    """
    Main function to run the honeypot simulator with command-line arguments
    """
    parser = argparse.ArgumentParser(description="Honeypot Attack Simulator")
    parser.add_argument("--target", default="127.0.0.1", help="Target IP address")
    parser.add_argument(
        "--intensity",
        choices=["low", "medium", "high"],
        default="medium",
        help="Simulation intensity level"
    )
    parser.add_argument(
        "--duration",
        type=int,
        default=300,
        help="Simulation duration in seconds"
    )

    args = parser.parse_args()

    simulator = HoneypotSimulator(args.target, args.intensity)

    try:
        simulator.run_continuous_simulation(args.duration)
    except KeyboardInterrupt:
        print("\n[*] Simulation interrupted by user")
    except Exception as e:
        print(f"[-] Simulation error: {e}")
    finally:
        print("\n[*] Simulation complete")

if __name__ == "__main__":
    main()

Wir haben in diesem Simulationsskript viel zu tun, also lassen Sie es uns Schritt für Schritt durchgehen. Ich habe auch Kommentare zu jeder Funktion und Operation hinzugefügt, um den Code etwas lesbarer zu machen.

Wir haben zunächst unsere Dienstklasse namens HoneypotSimulator. In dieser Klasse haben wir die Funktion __init__, die die grundlegende Konfiguration für unseren Simulator einrichtet. Sie nimmt zwei Parameter: eine Ziel-IP-Adresse (standardmäßig localhost) und ein Intensitätsniveau (standardmäßig „mittel“).

Wir definieren auch drei wichtige Komponenten: die Zielports, die untersucht werden sollen (gängige Dienste wie FTP, SSH, HTTP), Angriffsmodelle, die spezifisch für jeden Dienst sind (wie Anmeldeversuche und Befehle), und Intensitätseinstellungen, die steuern, wie aggressiv unsere Simulation durch Thread-Anzahlen und Zeitverzögerungen sein wird.

Die Funktion simulate_connection behandelt einzelne Verbindungsversuche zu einem bestimmten Port. Sie erstellt eine Socket-Verbindung, versucht, Dienstbanner abzurufen (wie SSH-Versioninformationen), und sendet dann geeignete Angriffsbefehle basierend auf dem Diensttyp. Wir haben eine Fehlerbehandlung für gängige Netzwerkprobleme hinzugefügt und auch realistische Verzögerungen zwischen den Befehlen eingefügt, um menschliche Interaktion zu simulieren.

Unsere Funktion simulate_port_scan fungiert wie ein Aufklärungstool, das systematisch jeden Port in unserer Zielliste überprüft. Es ist ähnlich, wie Werkzeuge wie nmap funktionieren – indem sie Ports nacheinander durchgehen, um zu sehen, welche Dienste verfügbar sind. Für jeden Port wird die Funktion simulate_connection aufgerufen und kleine zufällige Verzögerungen hinzugefügt, um das Scan-Muster natürlicher erscheinen zu lassen.

Die simulate_brute_force-Funktion verwaltet Listen von gängigen Benutzernamen und Passwörtern und versucht, verschiedene Kombinationen gegen Dienste wie FTP und SSH. Bei jedem Versuch wird eine neue Verbindung erstellt, die Anmeldedaten im richtigen Format für diesen Dienst gesendet und dann die Verbindung geschlossen. Dies hilft uns, zu testen, wie gut der Honeypot Credential Stuffing-Angriffe erkennt und protokolliert.

Die run_continuous_simulation-Funktion läuft für eine festgelegte Dauer und wählt zufällig zwischen verschiedenen Angriffstypen wie Port-Scanning, Brute-Force oder spezifischen Dienstangriffen. Sie verwendet den ThreadPoolExecutor von Python, um mehrere Angriffe gleichzeitig basierend auf dem angegebenen Intensitätsgrad auszuführen.

Schließlich haben wir die main-Funktion, die die Befehlszeilenschnittstelle für den Simulator bereitstellt. Sie verwendet argparse, um Befehlszeilenargumente zu verarbeiten, sodass Benutzer die Ziel-IP, den Intensitätsgrad und die Dauer der Simulation angeben können. Sie erstellt eine Instanz der HoneypotSimulator-Klasse und verwaltet die gesamte Ausführung, einschließlich der ordnungsgemäßen Handhabung von Benutzerunterbrechungen und Fehlern.

Nachdem der Simulator-Code in einem separaten Skript platziert wurde, führen Sie ihn mit dem folgenden Befehl aus:

# Mit Standardeinstellungen ausführen (mittlere Intensität, localhost, 5 Minuten)
python honeypot_simulator.py

# Mit benutzerdefinierten Einstellungen ausführen
python honeypot_simulator.py --target 192.168.1.100 --intensity high --duration 600

Da wir das Honeypot sowie den Simulator lokal auf demselben Rechner ausführen, wird das Ziel localhost sein. In einem realen Szenario oder wenn Sie das Honeypot in einer VM oder auf einem anderen Rechner ausführen, kann es jedoch etwas anderes sein – stellen Sie also sicher, dass Sie die IP vor dem Ausführen des Simulators bestätigen.

Wie man Honeypot-Daten analysiert

Lassen Sie uns schnell eine Hilfsfunktion schreiben, die es uns ermöglicht, alle vom Honeypot gesammelten Daten zu analysieren. Da wir dies in einer JSON-Protokolldatei gespeichert haben, können wir es bequem mit dem integrierten JSON-Paket parsen.

import datetime
import json

def analyze_logs(log_file):
    """Enhanced honeypot log analysis with temporal and behavioral patterns"""
    ip_analysis = {}
    port_analysis = {}
    hourly_attacks = {}
    data_patterns = {}

    # Sitzungsmuster verfolgen
    ip_sessions = {}
    attack_timeline = []

    with open(log_file, 'r') as f:
        for line in f:
            try:
                activity = json.loads(line)
                timestamp = datetime.datetime.fromisoformat(activity['timestamp'])
                ip = activity['remote_ip']
                port = activity['port']
                data = activity['data']

                # IP-Tracking initialisieren, falls neu
                if ip not in ip_analysis:
                    ip_analysis[ip] = {
                        'total_attempts': 0,
                        'first_seen': timestamp,
                        'last_seen': timestamp,
                        'targeted_ports': set(),
                        'unique_payloads': set(),
                        'session_count': 0
                    }

                # IP-Statistiken aktualisieren
                ip_analysis[ip]['total_attempts'] += 1
                ip_analysis[ip]['last_seen'] = timestamp
                ip_analysis[ip]['targeted_ports'].add(port)
                ip_analysis[ip]['unique_payloads'].add(data.strip())

                # Stündliche Muster verfolgen
                hour = timestamp.hour
                hourly_attacks[hour] = hourly_attacks.get(hour, 0) + 1

                # Analyse der Portzielmuster
                if port not in port_analysis:
                    port_analysis[port] = {
                        'total_attempts': 0,
                        'unique_ips': set(),
                        'unique_payloads': set()
                    }
                port_analysis[port]['total_attempts'] += 1
                port_analysis[port]['unique_ips'].add(ip)
                port_analysis[port]['unique_payloads'].add(data.strip())

                # Payload-Muster verfolgen
                if data.strip():
                    data_patterns[data.strip()] = data_patterns.get(data.strip(), 0) + 1

                # Angriffszeitlinie verfolgen
                attack_timeline.append({
                    'timestamp': timestamp,
                    'ip': ip,
                    'port': port
                })

            except (json.JSONDecodeError, KeyError) as e:
                continue

    # Analysebericht erstellen
    print("\n=== Honeypot Analysis Report ===")

    # 1. IP-basierte Analyse
    print("\nTop 10 Most Active IPs:")
    sorted_ips = sorted(ip_analysis.items(), 
                       key=lambda x: x[1]['total_attempts'], 
                       reverse=True)[:10]
    for ip, stats in sorted_ips:
        duration = stats['last_seen'] - stats['first_seen']
        print(f"\nIP: {ip}")
        print(f"Total Attempts: {stats['total_attempts']}")
        print(f"Active Duration: {duration}")
        print(f"Unique Ports Targeted: {len(stats['targeted_ports'])}")
        print(f"Unique Payloads: {len(stats['unique_payloads'])}")

    # 2. Portanalyse
    print("\nPort Targeting Analysis:")
    sorted_ports = sorted(port_analysis.items(),
                         key=lambda x: x[1]['total_attempts'],
                         reverse=True)
    for port, stats in sorted_ports:
        print(f"\nPort {port}:")
        print(f"Total Attempts: {stats['total_attempts']}")
        print(f"Unique Attackers: {len(stats['unique_ips'])}")
        print(f"Unique Payloads: {len(stats['unique_payloads'])}")

    # 3. Temporalanalyse
    print("\nHourly Attack Distribution:")
    for hour in sorted(hourly_attacks.keys()):
        print(f"Hour {hour:02d}: {hourly_attacks[hour]} attempts")

    # 4. Analyse der Angriffskomplexität
    print("\nAttacker Sophistication Analysis:")
    for ip, stats in sorted_ips:
        sophistication_score = (
            len(stats['targeted_ports']) * 0.4 +  # Portvielfalt
            len(stats['unique_payloads']) * 0.6   # Payload-Vielfalt
        )
        print(f"IP {ip}: Sophistication Score {sophistication_score:.2f}")

    # 5. Häufige Payload-Muster
    print("\nTop 10 Most Common Payloads:")
    sorted_payloads = sorted(data_patterns.items(),
                            key=lambda x: x[1],
                            reverse=True)[:10]
    for payload, count in sorted_payloads:
        if len(payload) > 50:  # Lange Payloads kürzen
            payload = payload[:50] + "..."
        print(f"Count {count}: {payload}")

Sie können dies in eine separate Skriptdatei einfügen und die Funktion auf den JSON-Protokollen aufrufen. Diese Funktion wird uns umfassende Einblicke aus der JSON-Datei basierend auf den gesammelten Daten bieten.

Unsere Analyse beginnt mit der Gruppierung der Daten in mehrere Kategorien wie IP-basierte Statistiken, Portzielmuster, stündliche Angriffverteilungen und Payload-Eigenschaften. Für jede IP verfolgen wir die Gesamtversuche, die ersten und letzten Sichtungszeiten, die angegriffenen Ports und die einzigartigen Payloads. Dies wird uns helfen, einzigartige Profile für Angreifer zu erstellen.

Wir untersuchen auch portbasierte Angriffsmuster, die die am häufigsten angegriffenen Ports und die Anzahl der einzigartigen Angreifer überwachen. Außerdem führen wir eine Analyse der Angriffskomplexität durch, die uns hilft, gezielte Angreifer zu identifizieren, wobei Faktoren wie angegriffene Ports und verwendete einzigartige Payloads berücksichtigt werden. Diese Analyse wird verwendet, um einfache Scanning-Aktivitäten von komplexen Angriffen zu trennen.

Die temporale Analyse hilft uns, Muster in den stündlichen Angriffversuchen zu identifizieren, die Muster im Angriffstiming und potenzielle automatisierte Zielkampagnen offenbaren. Schließlich veröffentlichen wir häufig gesehene Payloads, um häufige Angriffsschnüre oder -befehle zu identifizieren.

Sicherheitsüberlegungen

Bei der Bereitstellung dieses Honeypots sollten Sie die folgenden Sicherheitsmaßnahmen in Betracht ziehen:

  1. Führen Sie Ihren Honeypot in einer isolierten Umgebung aus. Typischerweise in einer VM oder auf Ihrem lokalen Rechner, der hinter einem NAT und einer Firewall steht.

  2. Führen Sie den Honeypot mit minimalen Systemprivilegien aus (typischerweise nicht als Root), um das Risiko im Falle einer Kompromittierung zu verringern.

  3. Seien Sie vorsichtig mit gesammelten Daten, wenn Sie planen, diese jemals als produktionsfähigen oder Forschungs-Honeypot einzusetzen, da sie Malware oder sensible Informationen enthalten können.

  4. Implementieren Sie robuste Überwachungsmechanismen, um Versuche zu erkennen, aus der Honeypot-Umgebung auszubrechen.

Fazit

Damit haben wir unseren Honeypot aufgebaut, einen Simulator geschrieben, um Angriffe auf unseren Honeypot zu simulieren, und die Daten aus unseren Honeypot-Protokollen analysiert, um einige einfache Rückschlüsse zu ziehen. Es ist eine ausgezeichnete Möglichkeit, sowohl offensive als auch defensive Sicherheitskonzepte zu verstehen. Sie können in Betracht ziehen, darauf aufzubauen, um komplexere Erkennungssysteme zu erstellen und Funktionen wie:

  1. Dynamische Dienstemulation basierend auf Angriffsverhalten

  2. Integration mit Bedrohungsintelligenzsystemen, die eine bessere Inferenzanalyse dieser gesammelten Honeypot-Protokolle durchführen werden

  3. Erfassen Sie sogar umfassendere Protokolle über IP-, Port- und Netzwerkdaten hinaus durch fortschrittliche Protokollierungsmechanismen

  4. Fügen Sie maschinelles Lernen hinzu, um Angriffsmuster zu erkennen

Denken Sie daran, dass Honeypots zwar leistungsstarke Sicherheitswerkzeuge sind, sie jedoch Teil einer umfassenden defensiven Sicherheitsstrategie sein sollten und nicht die einzige Verteidigungslinie.

Ich hoffe, Sie haben gelernt, wie Honeypots funktionieren, was ihr Zweck ist und auch ein wenig Python-Programmierung!