Python'da bir balkon nasıl inşa edilir: Güvenlik Aldatma için Pratik Bir Kılavuz


Siber güvenlikte, bir balkon, sistemi tehlikeye atmaya çalışan potansiyel saldırganları çekmek ve tespit etmek için tasarlanmış bir tuzak sistemidir. Tıpkı açıkta oturan bir tencerede bir tencerede sinekleri çekecekti.

Bu göbekotları sisteminiz için güvenlik kameraları olarak düşünün. Tıpkı bir güvenlik kamerasının kimin bir binaya girmeye çalıştığını ve bunu nasıl yaptıklarını anlamamıza yardımcı olduğu gibi, bu balpotlar kimin sisteminize saldırmaya çalıştığını ve hangi teknikleri kullandıklarını anlamanıza yardımcı olacaktır.

Bu öğreticinin sonunda, Python'da bir demo balkospot yazabilir ve Honeypots'un nasıl çalıştığını anlayabilirsiniz.

İçindekiler

  • Honeypot türlerini anlamak

  • Geliştirme Ortamınızı Nasıl Kurabilirsiniz?

  • Çekirdek Balküpü Nasıl Oluşturulur

    • Ağ dinleyicilerini uygulayın

    • Honeypot'u çalıştırın

    • Balküpü Saldırı Simülatörünü Yazın

  • Honeypot verileri nasıl analiz edilir

  • Güvenlik Hususları

  • Çözüm

Honeypot türlerini anlamak

Kendi bal küpümüzü tasarlamaya başlamadan önce, bunların farklı türlerini hızlıca anlayalım:

  1. Üretim Honeypot'ları: Bu tür honeypot'lar gerçek bir üretim ortamına yerleştirilir ve gerçek güvenlik saldırılarını tespit etmek için kullanılır. Genellikle tasarım açısından basittirler, bakımı ve dağıtımı kolaydır ve riski azaltmak için sınırlı etkileşim sunarlar.

  2. Araştırma Honeypots: Bunlar, güvenlik araştırmacıları tarafından saldırı modellerini incelemek, bu modeller üzerinde ampirik analiz yapmak, kötü amaçlı yazılım örnekleri toplamak ve daha önce keşfedilmeyen yeni saldırı tekniklerini anlamak için kurulan daha karmaşık sistemlerdir. Üretim ortamında bir uygulama gibi davranmak yerine genellikle tüm işletim sistemlerini veya ağları taklit ederler.

Bu öğretici için, bağlantı denemelerini ve temel saldırgan davranışını günlüğe sürdüren bir orta etkileşim hanımı oluşturacağız.

Geliştirme ortamınızı nasıl kurabilirsiniz?

Python'da geliştirme ortamınızı kurarak başlayalım. Aşağıdaki komutları çalıştırın:

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

# Configure logging directory
LOG_DIR = Path("honeypot_logs")
LOG_DIR.mkdir(exist_ok=True)

Yerleşik kütüphanelere sadık kalacağız, böylece herhangi bir harici bağımlılık kurmamıza gerek kalmayacak. Günlüklerimizi honeypot_logs dizininde saklayacağız.

Çekirdek Balküpü Nasıl Oluşturulur

Temel balkotumuz üç bileşenden oluşacak:

  1. Bağlantıları kabul eden bir ağ dinleyicisi

  2. Etkinlikleri kaydetmek için bir günlük sistemi

  3. Saldırganlarla etkileşim kurmak için temel bir emülasyon hizmeti

Şimdi çekirdek Honeypot sınıfını başlatarak başlayalım:

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]  # Default ports to monitor
        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:
            # Send appropriate banner for the service
            if port in service_banners:
                client_socket.send(service_banners[port].encode())

            # Receive data from attacker
            while True:
                data = client_socket.recv(1024)
                if not data:
                    break

                self.log_activity(port, remote_ip, data)

                # Send fake response
                client_socket.send(b"Command not recognized.\r\n")

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

Bu sınıfta çok sayıda önemli bilgi var, bu yüzden her işlevi tek tek gözden geçirelim.

__ init __ işlevi, Honeypot'u barındıracağımız IP ve bağlantı noktası numaralarını ve günlük dosyasının yolu/dosya adını kaydeder. Ayrıca, Honeypot'a sahip olduğumuz toplam aktif bağlantı sayısının kaydını da koruyacağız.

log_activity işlevi, IP, IP'nin bağlantı kurduğu IP, veriler ve bağlantı noktası hakkında bilgi alacaktır. Ardından bu bilgileri JSON biçimlendirilmiş günlük dosyamıza ekleyeceğiz.

handle_connection işlevi, sahip olduğumuz farklı bağlantı noktalarında çalışacak bu hizmetleri taklit edecek. Honeypot'un 21, 22, 80 ve 443 bağlantı noktalarında çalıştıracağız. Bu hizmetler sırasıyla FTP, SSH, HTTP ve HTTPS protokolü içindir. Dolayısıyla, Honeypot ile etkileşime girmeye çalışan herhangi bir saldırgan bu hizmetleri bu bağlantı noktalarında beklemelidir.

Bu hizmetlerin davranışını taklit etmek için gerçekte kullandıkları hizmet bannerlarını kullanacağız. Bu işlev, saldırgan bağlandığında önce uygun banner'ı gönderecek, ardından verileri alıp günlüğe kaydedecektir. Honeypot ayrıca saldırgana "Komut tanınmadı" şeklinde sahte bir yanıt gönderecektir.

Ağ Dinleyicilerini Uygulama

Şimdi gelen bağlantıları yönetecek ağ dinleyicilerini uygulayalım. Bunun için basit soket programlamayı kullanacağız. Soket programlamanın nasıl çalıştığını bilmiyorsanız bununla ilgili bazı kavramları açıklayan bu makaleye göz atın.

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]}")

            # Handle connection in separate thread
            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}")

start_listener işlevi sunucuyu başlatacak ve sağlanan bağlantı noktasını dinleyecektir. Bizim için bind_ip 0.0.0.0 olacaktır; bu, sunucunun tüm ağ arayüzlerini dinleyeceğini gösterir.

Şimdi, her yeni bağlantıyı ayrı bir iş parçacığında ele alacağız, çünkü birden fazla saldırganın balkon ile etkileşime girmeye çalıştığı veya saldıran bir komut dosyası veya aracının balkosunu taradığı durumlar olabilir. İş parçacığının nasıl çalıştığının farkında değilseniz, Python'daki iplik ve eşzamanlılığı açıklayan bu makaleye göz atabilirsiniz.

Ayrıca bu işlevi çekirdek Honeypot sınıfına koyduğunuzdan emin olun.

Balküpünü Çalıştır

Şimdi Honeypot'umuzu başlatacak Main işlevini oluşturalım.

def main():
    honeypot = Honeypot()

    # Start listeners for each port in separate threads
    for port in honeypot.ports:
        listener_thread = threading.Thread(
            target=honeypot.start_listener,
            args=(port,)
        )
        listener_thread.daemon = True
        listener_thread.start()

    try:
        # Keep main thread alive
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        print("\n[*] Shutting down honeypot...")
        sys.exit(0)

if __name__ == "__main__":
    main()

Bu işlev Honeypot sınıfını başlatır ve tanımlı bağlantı noktalarımızın (21,22,80,443) her biri için dinleyicileri ayrı bir iş parçacığı olarak başlatır. Şimdi asıl programımızı çalıştıran ana iş parçacığımızı sonsuz bir döngüye sokarak canlı tutacağız. Bunların hepsini bir komut dosyasında bir araya getirin ve çalıştırın.

Balküpü Saldırı Simülatörünü Yazın

Şimdi bazı saldırı senaryolarını simüle etmeye çalışalım ve JSON günlük dosyamızda bazı veriler toplayabilmemiz için Honeypot'umuzu hedeflemeye çalışalım.

Bu simülatör, honeypot'larla ilgili birkaç önemli hususu göstermemize yardımcı olacaktır:

  1. Gerçekçi Saldırı Desenleri: Simülatör, bağlantı noktası taraması, kaba kuvvet girişimleri ve hizmete özgü istismarlar gibi ortak saldırı modellerini simüle edecektir.

  2. Değişken yoğunluk: Simülatör, bal küpünüzün farklı yükleri nasıl kaldırdığını test etmek için simülasyonun yoğunluğunu ayarlayacaktır.

  3. Birkaç saldırı türü: Gerçek saldırganların deneyebileceği farklı saldırı türlerini gösterecek ve balkonunuzun her birine nasıl tepki verdiğini anlamanıza yardımcı olacak.

  4. Eşzamanlı bağlantılar: Simülatör, bal küpünüzün birden fazla eşzamanlı bağlantıyı nasıl yönettiğini test etmek için iş parçacığı kullanacaktır.

# 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"):
        # Configuration for the simulator
        self.target_ip = target_ip
        self.intensity = intensity

        # Common ports that attackers often probe
        self.target_ports = [21, 22, 23, 25, 80, 443, 3306, 5432]

        # Dictionary of common commands used by attackers for different services
        self.attack_patterns = {
            21: [  # FTP commands
                "USER admin\r\n",
                "PASS admin123\r\n",
                "LIST\r\n",
                "STOR malware.exe\r\n"
            ],
            22: [  # SSH attempts
                "SSH-2.0-OpenSSH_7.9\r\n",
                "admin:password123\n",
                "root:toor\n"
            ],
            80: [  # HTTP requests
                "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"
            ]
        }

        # Intensity settings affect the frequency and volume of simulated attacks
        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:
            # Create a new socket connection
            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))

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

            # Send attack patterns based on the port
            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())

                    # Wait for response
                    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}")

                    # Add realistic delay between commands
                    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:
                # Mix of different attack patterns
                simulation_choices = [
                    lambda: self.simulate_port_scan(),
                    lambda: self.simulate_brute_force(21),
                    lambda: self.simulate_brute_force(22),
                    lambda: self.simulate_connection(80)
                ]

                # Randomly choose and execute an attack pattern
                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()

Bu simülasyon senaryosunda çok şey var, bu yüzden tek tek parçalayalım. Ayrıca, bunu kodda biraz daha okunabilir hale getirmek için her işlev ve işlem için yorum ekledim.

İlk olarak HoneypotSimulator adlı yardımcı programımız var. Bu sınıfta, simülatörümüz için temel yapılandırmayı ayarlayan __ init __ işlevine sahibiz. İki parametre alır: bir hedef IP adresi (Localhost'a temerrüde düşme) ve yoğunluk seviyesi ("Orta" için temerrüde düşme).

Ayrıca üç önemli bileşen tanımlıyoruz: prob için hedef bağlantı noktaları (FTP, SSH, HTTP), her hizmete özgü saldırı modelleri (giriş denemeleri ve komutlar gibi) ve simülasyonumuzun iş parçacığından ne kadar agresif olacağını kontrol eden yoğunluk ayarları Sayım ve zamanlama gecikmeleri.

simulate_connection işlevi, belirli bir bağlantı noktasına yapılan bireysel bağlantı girişimlerini yönetir. Bir soket bağlantısı oluşturur, herhangi bir hizmet başlığını (SSH sürüm bilgisi gibi) almaya çalışır ve ardından hizmet türüne göre uygun saldırı komutlarını gönderir. Yaygın ağ sorunları için hata yönetimi ekledik ve ayrıca insan etkileşimini taklit etmek için komutlar arasına gerçekçi gecikmeler ekledik.

simulate_port_scan işlevimiz, hedef listemizdeki her bağlantı noktasını sistematik olarak kontrol edecek bir keşif aracı gibi davranır. Bu, nmap gibi araçların çalışma şekline benzer; hangi hizmetlerin mevcut olduğunu görmek için bağlantı noktalarını tek tek gezmek. Her bağlantı noktası için simulate_connection işlevini çağırır ve tarama modelinin daha doğal görünmesini sağlamak için küçük rastgele gecikmeler ekler.

simulate_brute_force işlevi, FTP ve SSH gibi hizmetlere karşı farklı kombinasyonlar deneyerek ortak kullanıcı adları ve şifrelerin listesini tutar. Her denemede yeni bir bağlantı oluşturur, oturum açma kimlik bilgilerini söz konusu hizmet için doğru biçimde gönderir ve ardından bağlantıyı kapatır. Bu, bal küpünün kimlik bilgisi doldurma saldırılarını ne kadar iyi algılayıp günlüğe kaydettiğini test etmemize yardımcı olur.

run_continour_simulation işlevi belirli bir süre için çalışır, bağlantı noktası tarama, kaba kuvvet veya belirli hizmet saldırıları gibi farklı saldırı türleri arasında rastgele seçim yapar. Belirtilen yoğunluk seviyesine göre aynı anda birden fazla saldırı çalıştırmak için Python'un ThreadPoolexecutor kullanır.

Son olarak, simülatör için komut satırı arayüzünü sağlayan main fonksiyonumuz var. Komut satırı argümanlarını işlemek için argparse'i kullanarak kullanıcıların simülasyonun hedef IP'sini, yoğunluk düzeyini ve süresini belirlemesine olanak tanır. HoneypotSimulator sınıfının bir örneğini oluşturur ve kullanıcı kesintilerinin ve hatalarının doğru şekilde ele alınması da dahil olmak üzere genel yürütmeyi yönetir.

Simülatör kodunu ayrı bir script içerisine koyduktan sonra aşağıdaki komutla çalıştırın:

# Run with default settings (medium intensity, localhost, 5 minutes)
python honeypot_simulator.py

# Run with custom settings
python honeypot_simulator.py --target 192.168.1.100 --intensity high --duration 600

Honeypot'u ve yerel olarak aynı makinede simülatör çalıştırdığımız için, hedef localhost olacaktır. Ancak gerçek bir senaryoda başka bir şey olabilir veya balkosunu bir VM'de veya farklı bir makinede çalıştırıyorsanız - bu nedenle simülatör çalıştırmadan önce IP'yi onayladığınızdan emin olun.

Honeypot verileri nasıl analiz edilir

Honeypot tarafından toplanan tüm verileri analiz etmemizi sağlayacak bir yardımcı fonksiyonu hızlıca yazalım. Bunu bir JSON günlük dosyasında sakladığımız için yerleşik JSON paketini kullanarak rahatlıkla ayrıştırabiliriz.

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 = {}

    # Track session patterns
    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']

                # Initialize IP tracking if new
                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
                    }

                # Update IP statistics
                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())

                # Track hourly patterns
                hour = timestamp.hour
                hourly_attacks[hour] = hourly_attacks.get(hour, 0) + 1

                # Analyze port targeting patterns
                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())

                # Track payload patterns
                if data.strip():
                    data_patterns[data.strip()] = data_patterns.get(data.strip(), 0) + 1

                # Track attack timeline
                attack_timeline.append({
                    'timestamp': timestamp,
                    'ip': ip,
                    'port': port
                })

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

    # Analysis Report Generation
    print("\n=== Honeypot Analysis Report ===")

    # 1. IP-based Analysis
    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. Port Analysis
    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. Temporal Analysis
    print("\nHourly Attack Distribution:")
    for hour in sorted(hourly_attacks.keys()):
        print(f"Hour {hour:02d}: {hourly_attacks[hour]} attempts")

    # 4. Attack Sophistication Analysis
    print("\nAttacker Sophistication Analysis:")
    for ip, stats in sorted_ips:
        sophistication_score = (
            len(stats['targeted_ports']) * 0.4 +  # Port diversity
            len(stats['unique_payloads']) * 0.6   # Payload diversity
        )
        print(f"IP {ip}: Sophistication Score {sophistication_score:.2f}")

    # 5. Common Payload Patterns
    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:  # Truncate long payloads
            payload = payload[:50] + "..."
        print(f"Count {count}: {payload}")

Bunu ayrı bir komut dosyası dosyasına yerleştirebilir ve JSON günlüklerinde işlevi çağırabilirsiniz. Bu işlev bize toplanan verilere dayanarak JSON dosyasından kapsamlı bilgiler sağlayacaktır.

Analizimiz, verileri IP tabanlı istatistikler, bağlantı noktası hedefleme kalıpları, saatlik saldırı dağılımları ve yük özellikleri gibi çeşitli kategorilere ayırarak başlar. Her IP için, ilk ve son görülen zamanları, hedeflenen bağlantı noktalarını ve benzersiz yükleri toplam denemeleri izliyoruz. Bu, saldırganlar için benzersiz profiller oluşturmamıza yardımcı olacaktır.

Burada ayrıca en sık hedeflenen bağlantı noktalarını ve kaç benzersiz saldırgan tarafından izlendiğini izleyen bağlantı noktası tabanlı saldırı modellerini de inceliyoruz. Ayrıca, hedeflenen bağlantı noktaları ve kullanılan benzersiz yükler gibi faktörleri göz önünde bulundurarak, hedeflenen saldırganları belirlememize yardımcı olan bir saldırı karmaşıklığı analizi de gerçekleştiriyoruz. Bu analiz, basit tarama etkinliklerini ve karmaşık saldırıları ayırmak için kullanılır.

Geçici analiz, saldırı zamanlaması ve potansiyel otomatik hedefleme kampanyalarındaki kalıpları ortaya çıkaran saatlik saldırı girişimlerindeki kalıpları belirlememize yardımcı olur. Son olarak, yaygın olarak görülen saldırı dizelerini veya komutlarını tanımlamak için yaygın olarak görülen yükleri yayınladık.

Güvenlik Hususları

Bu göbekotu dağıtırken, aşağıdaki güvenlik önlemlerini göz önünde bulundurduğunuzdan emin olun:

  1. Yalgılarınızı izole bir ortamda çalıştırın. Tipik olarak bir VM'nin içinde veya yerel makinenizde bir NAT ve bir güvenlik duvarının arkasında.

  2. Güvenliği ihlal edildiğinde riski azaltmak için bal küpünü minimum sistem ayrıcalıklarıyla (genellikle kök olarak değil) çalıştırın.

  3. Toplanan verileri üretim düzeyinde dağıtmayı veya balküpü araştırmayı planlıyorsanız, kötü amaçlı yazılım veya hassas bilgiler içerebileceğinden dikkatli olun.

  4. Honeypot ortamından çıkma girişimlerini tespit etmek için güçlü izleme mekanizmaları uygulayın.

Çözüm

Bununla honeypotumuzu oluşturduk, honeypotumuza yönelik saldırıları simüle edecek bir simülatör yazdık ve birkaç basit çıkarım yapmak için honeypot loglarımızdan verileri analiz ettik. Hem saldırı hem de savunma güvenliği kavramlarını anlamanın mükemmel bir yoludur. Daha karmaşık algılama sistemleri oluşturmak için bunun üzerine inşa etmeyi ve aşağıdaki gibi özellikler eklemeyi düşünebilirsiniz:

  1. Saldırı davranışına dayalı dinamik hizmet emülasyonu

  2. Toplanan bu balkospot günlüklerinin daha iyi çıkarım analizini gerçekleştirecek tehdit istihbarat sistemleriyle entegrasyon

  3. Gelişmiş günlüğü mekanizmaları aracılığıyla IP, bağlantı noktası ve ağ verilerinin ötesinde kapsamlı günlükler bile toplayın

  4. Saldırı modellerini tespit etmek için makine öğrenimi yetenekleri ekleyin

Honeypotlar güçlü güvenlik araçları olmasına rağmen, tek savunma hattı değil, kapsamlı bir savunma güvenlik stratejisinin bir parçası olması gerektiğini unutmayın.

Umarım Honeypots'un nasıl çalıştığını, amaçlarının yanı sıra biraz Python programlaması da öğrendiniz!