چگونه یک هانی پات بسازیم: راهنمای عملی برای فریب امنیتی

زمان لازم برای مطالعه: 12 دقیقه

[*][*]

در امنیت سایبری، هانی پات یک سیستم فریبنده است که برای جذب و سپس شناسایی مهاجمان احتمالی که سعی در به خطر انداختن سیستم دارند، طراحی شده است. درست مانند یک گلدان عسل که در فضای باز نشسته باشد، مگس ها را جذب می کند.

به این Honeypot ها به عنوان دوربین های امنیتی برای سیستم خود فکر کنید. همانطور که یک دوربین امنیتی به ما کمک می‌کند بفهمیم چه کسی می‌خواهد به یک ساختمان نفوذ کند و چگونه این کار را انجام می‌دهد، این هانی‌پات‌ها به شما کمک می‌کنند بفهمید چه کسی می‌خواهد به سیستم شما حمله کند و از چه تکنیک‌هایی استفاده می‌کند.

در پایان این آموزش، می‌توانید یک هانی‌پات دمو در پایتون بنویسید و متوجه شوید که هانی‌پات چگونه کار می‌کند.

فهرست مطالب

• آشنایی با انواع هانی پات

• چگونه محیط توسعه خود را تنظیم کنید

• چگونه هانی پات اصلی بسازیم

  • شبکه شنوندگان را پیاده سازی کنید

  • Honeypot را اجرا کنید

  • شبیه ساز حمله هانی پات را بنویسید

• روش تجزیه و تحلیل داده های Honeypot

• ملاحظات امنیتی

• نتیجه گیری

آشنایی با انواع هانی پات

قبل از اینکه شروع به طراحی Honeypot خود کنیم، بیایید به سرعت انواع مختلف آنها را درک کنیم:

1. هانی پات های تولیدی: این نوع هانی پات ها در یک محیط تولید واقعی قرار می گیرند و برای شناسایی حملات امنیتی واقعی استفاده می شوند. آنها معمولاً از نظر طراحی ساده هستند، نگهداری و استقرار آنها آسان است و تعامل محدودی برای کاهش ریسک ارائه می دهند.

2. تحقیقات Honeypot: اینها سیستم های پیچیده تری هستند که توسط محققان امنیتی برای مطالعه الگوهای حمله، انجام تجزیه و تحلیل تجربی راه اندازی شده اند. روی این الگوها، نمونه‌های بدافزار را جمع‌آوری می‌کنند و تکنیک‌های حمله جدیدی را که قبلاً کشف نشده‌اند، درک می‌کنند. آنها اغلب کل سیستم عامل ها یا شبکه ها را شبیه سازی می کنند تا اینکه مانند یک برنامه کاربردی در محیط تولید رفتار کنند.

برای این آموزش، ما یک هانی‌پات با تعامل متوسط ​​می‌سازیم که تلاش‌های اتصال و رفتار اصلی مهاجم را ثبت می‌کند.

چگونه محیط توسعه خود را تنظیم کنید

بیایید با تنظیم محیط توسعه خود در پایتون شروع کنیم. دستورات زیر را اجرا کنید:

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)

ما به کتابخانه های ساخته شده پایبند خواهیم بود، بنابراین نیازی به نصب هیچ گونه وابستگی خارجی نخواهیم داشت. ما سیاهههای مربوط به خود را در honeypot_logs دایرکتوری

چگونه هانی پات اصلی بسازیم

هانی پات اصلی ما از سه جزء تشکیل شده است:

1. شنونده شبکه ای که اتصالات را می پذیرد

2. یک سیستم ثبت برای ثبت فعالیت ها

3. یک سرویس شبیه سازی اولیه برای تعامل با مهاجمان

حالا بیایید با مقداردهی اولیه کلاس اصلی Honeypot شروع کنیم:

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()

این کلاس اطلاعات مهم زیادی در خود دارد، بنابراین اجازه دهید هر تابع را یکی یکی مرور کنیم.

را __init__ تابع شماره ip و پورت را ثبت می کند روی که ما خواهیم کرد host honeypot و همچنین مسیر / نام فایل فایل لاگ. ما همچنین رکوردی از تعداد کل اتصالات فعالی که به هانی پات داریم حفظ خواهیم کرد.

را log_activity تابع قرار است اطلاعات مربوط به IP، داده ها و پورتی را که IP سعی کرده به آن متصل شود، دریافت کند. سپس این اطلاعات را به فایل log با فرمت JSON اضافه می کنیم.

را handle_connection تابع قرار است از این خدماتی که در حال اجرا هستند تقلید کند روی پورت های مختلفی که داریم ما هانی پات را اجرا خواهیم کرد روی پورت های 21، 22، 80 و 443. این سرویس ها به ترتیب برای پروتکل FTP، SSH، HTTP و HTTPS هستند. بنابراین هر مهاجمی که سعی در تعامل با هانی پات دارد باید منتظر این خدمات باشد روی این پورت ها

برای تقلید از رفتار این سرویس‌ها، از بنرهای خدماتی استفاده می‌کنیم که در واقعیت استفاده می‌کنند. این تابع هنگام اتصال مهاجم ابتدا بنر مناسب را ارسال می کند و سپس داده ها را دریافت کرده و آنها را ثبت می کند. هانی پات همچنین یک پاسخ جعلی ارسال می کند.فرمان شناسایی نشدبازگشت به مهاجم.

شبکه شنوندگان را پیاده سازی کنید

حالا بیایید شنونده های شبکه ای را پیاده سازی کنیم که اتصالات ورودی را مدیریت می کنند. برای این، ما از برنامه نویسی سوکت ساده استفاده خواهیم کرد. اگر از روش عملکرد برنامه نویسی سوکت آگاه نیستید، این مقاله را بررسی کنید که برخی از مفاهیم مرتبط با آن را توضیح می دهد.

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

        print(f"[*] Listening روی {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 روی port {port}: {e}")

را start_listener تابع سرور را راه اندازی می کند و گوش می دهد روی پورت ارائه شده را bind_ip برای ما خواهد بود 0.0.0.0 که نشان می دهد سرور در حال گوش دادن خواهد بود روی تمام رابط های شبکه

اکنون، ما هر اتصال جدید را در یک رشته جداگانه مدیریت خواهیم کرد، زیرا ممکن است مواردی وجود داشته باشد که چندین مهاجم سعی در تعامل با honeypot داشته باشند یا یک اسکریپت یا ابزار مهاجم در حال اسکن honeypot است. اگر از روش کار threading آگاه نیستید، می توانید این مقاله را بررسی کنید که رشته و همزمانی در پایتون را توضیح می دهد.

همچنین، مطمئن شوید که این تابع را در هسته قرار دهید Honeypot کلاس

Honeypot را اجرا کنید

حالا بیایید ایجاد کنیم main عملکردی که هانی پات ما را شروع می کند.

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()

این تابع نمونه سازی می کند Honeypot کلاس و شنوندگان را برای هر یک از پورت های تعریف شده ما (21،22،80،443) به عنوان یک رشته جداگانه شروع می کند. اکنون، ما موضوع اصلی خود را که برنامه واقعی ما را اجرا می کند، با قرار دادن آن در یک حلقه بی نهایت زنده نگه می داریم. همه اینها را در یک اسکریپت قرار داده و اجرا کنید.

شبیه ساز حمله هانی پات را بنویسید

حال بیایید سعی کنیم برخی از سناریوهای حمله را شبیه سازی کنیم و honeypot خود را هدف قرار دهیم تا بتوانیم برخی از داده ها را در فایل log JSON خود جمع آوری کنیم.

این شبیه ساز به ما کمک می کند تا چند جنبه مهم در مورد هانی پات ها را نشان دهیم:

1. الگوهای حمله واقعی: شبیه ساز الگوهای حمله رایج مانند اسکن پورت، تلاش های brute force و سوء استفاده های خاص سرویس را شبیه سازی می کند.

2. شدت متغیر: شبیه ساز شدت شبیه سازی را تنظیم می کند تا آزمایش کند که هانی پات شما چگونه بارهای مختلف را کنترل می کند.

3. چندین نوع حمله: انواع مختلفی از حملاتی را که مهاجمان واقعی ممکن است انجام دهند را نشان می‌دهد و به شما کمک می‌کند بفهمید که هانی‌پات شما به هر کدام چگونه پاسخ می‌دهد.

4. اتصالات همزمان: شبیه ساز از threading استفاده می کند تا بررسی کند که Honeypot شما چگونه چندین اتصال همزمان را کنترل می کند.

# 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 روی 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 روی port {port}")
        except socket.timeout:
            print(f"[-] Connection timeout روی 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()

راه زیادی داریم روی در این اسکریپت شبیه سازی، پس بیایید آن را یکی یکی تجزیه کنیم. من همچنین برای هر عملکرد و عملیات نظراتی اضافه کرده‌ام تا این موضوع در کد کمی قابل خواندن باشد.

ما ابتدا کلاس کاربردی خود را به نام the داریم HoneypotSimulator. در این کلاس، ما باید __init__ تابعی که پیکربندی اولیه را برای شبیه ساز ما تنظیم می کند. این دو پارامتر نیاز دارد: یک آدرس IP هدف (پیش‌فرض به localhost) و یک سطح شدت (پیش فرض به “متوسط”).

ما همچنین سه جزء مهم را تعریف می‌کنیم: پورت‌های هدف برای کاوش (سرویس‌های رایج مانند FTP، SSH، HTTP)، الگوهای حمله خاص برای هر سرویس (مانند تلاش‌ها و دستورات ورود به سیستم)، و تنظیمات شدت که کنترل می‌کنند شبیه‌سازی ما تا چه حد تهاجمی خواهد بود. شمارش و تاخیرهای زمانی

را simulate_connection تابع تلاش های جداگانه برای اتصال به یک پورت خاص را مدیریت می کند. این یک اتصال سوکت ایجاد می کند، سعی می کند هر بنر سرویس (مانند اطلاعات نسخه SSH) را دریافت کند، و سپس دستورات حمله مناسب را بر اساس ارسال می کند. روی نوع خدمات ما مدیریت خطا را برای مسائل رایج شبکه اضافه کرده ایم و همچنین تاخیرهای واقعی بین دستورات را برای تقلید از تعامل انسانی اضافه کرده ایم.

ما simulate_port_scan تابع مانند یک ابزار شناسایی عمل می کند، که به طور سیستماتیک هر پورت را در لیست هدف ما بررسی می کند. شبیه ابزارهاست nmap کار – از طریق پورت ها یک به یک بروید تا ببینید چه خدماتی در دسترس است. برای هر پورت، آن را فراخوانی می کند simulate_connection عملکرد و تاخیرهای تصادفی کوچکی را اضافه می کند تا الگوی اسکن طبیعی تر به نظر برسد.

را simulate_brute_force تابع لیستی از نام‌های کاربری و رمزهای عبور رایج را حفظ می‌کند و از ترکیب‌های مختلف در برابر سرویس‌هایی مانند FTP و SSH استفاده می‌کند. برای هر تلاش، یک اتصال جدید ایجاد می کند، اعتبار ورود به سیستم را با فرمت صحیح برای آن سرویس ارسال می کند و سپس اتصال را می بندد. این به ما کمک می کند تا بررسی کنیم که هانی پات چقدر حملات پر کردن اعتبار را شناسایی و ثبت می کند.

را run_continuous_simulation تابع برای مدت زمان مشخصی اجرا می شود و به طور تصادفی بین انواع حملات مختلف مانند اسکن پورت، نیروی brute force یا حملات سرویس خاص انتخاب می شود. از پایتون استفاده می کند ThreadPoolExecutor برای اجرای چندین حمله به طور همزمان بر اساس روی سطح شدت مشخص شده

در نهایت، ما باید main تابعی که فراهم می کند command-line رابط برای شبیه ساز استفاده می کند argparse رسیدگی کند command-line آرگومان ها، به کاربران اجازه می دهد IP هدف، سطح شدت و مدت شبیه سازی را مشخص کنند. این یک نمونه از را ایجاد می کند HoneypotSimulator کلاس و اجرای کلی، از جمله مدیریت صحیح وقفه ها و خطاهای کاربر را مدیریت می کند.

پس از قرار دادن کد شبیه ساز در یک اسکریپت جداگانه، آن را با دستور زیر اجرا کنید:

# 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

از آنجایی که ما در حال اجرای هانی پات و همچنین شبیه ساز هستیم روی همان ماشین به صورت محلی، هدف خواهد بود localhost. اما در یک سناریوی واقعی می تواند چیز دیگری باشد یا اگر هانی پات را در یک ماشین مجازی یا ماشین دیگری اجرا می کنید – بنابراین مطمئن شوید که قبل از اجرای شبیه ساز IP را تأیید کرده اید.

روش تجزیه و تحلیل داده های Honeypot

بیایید به سرعت یک تابع کمکی بنویسیم که به ما امکان می دهد تمام داده های جمع آوری شده توسط Honeypot را تجزیه و تحلیل کنیم. از آنجایی که ما این را در یک فایل گزارش JSON ذخیره کرده ایم، می توانیم به راحتی آن را با استفاده از بسته داخلی JSON تجزیه کنیم.

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

می توانید آن را در یک فایل اسکریپت جداگانه قرار دهید و تابع را فراخوانی کنید روی گزارش های JSON این تابع اطلاعات جامعی را از فایل JSON به ما ارائه می دهد روی داده های جمع آوری شده

تجزیه و تحلیل ما با گروه بندی داده ها در چندین دسته مانند آمار مبتنی بر IP، الگوهای هدف گیری پورت، توزیع حمله ساعتی و ویژگی های بار شروع می شود. برای هر IP، کل تلاش‌ها، اولین و آخرین دفعات مشاهده، پورت‌های هدفمند و بارهای منحصر به فرد را ردیابی می‌کنیم. این به ما کمک می کند تا پروفایل های منحصر به فردی برای مهاجمان بسازیم.

ما همچنین الگوهای حمله مبتنی بر پورت را در اینجا بررسی می‌کنیم که اغلب پورت‌های هدف‌گیری شده و تعداد مهاجمان منحصربه‌فرد را بررسی می‌کنند. ما همچنین یک تجزیه و تحلیل پیچیده حمله را انجام می دهیم که به ما کمک می کند تا مهاجمان هدفمند را با در نظر گرفتن عواملی مانند پورت های هدفمند و بارهای منحصر به فرد مورد استفاده شناسایی کنیم. این تحلیل برای جداسازی فعالیت های اسکن ساده و حملات پیچیده استفاده می شود.

تجزیه و تحلیل زمانی به ما کمک می‌کند تا الگوهایی را در تلاش‌های حمله ساعتی شناسایی کنیم که الگوهای زمان‌بندی حمله و کمپین‌های هدف‌گیری خودکار بالقوه را آشکار می‌کند. در نهایت، ما بارهای متداول دیده شده را برای شناسایی رشته ها یا دستورات حمله که معمولاً دیده می شوند منتشر می کنیم.

ملاحظات امنیتی

هنگام استقرار این هانی پات، مطمئن شوید که اقدامات امنیتی زیر را در نظر گرفته اید:

1. هانی پات خود را در یک محیط ایزوله اجرا کنید. به طور معمول در داخل یک VM، یا روی ماشین محلی شما که پشت NAT و فایروال قرار دارد.

2. هانی پات را با حداقل امتیازات سیستم اجرا کنید (معمولاً نه به عنوان root) برای کاهش ریسک در صورت به خطر افتادن.

3. اگر قصد دارید آن‌ها را به‌عنوان یک هانی‌پات با درجه تولید یا تحقیقاتی استفاده کنید، مراقب داده‌های جمع‌آوری‌شده باشید، زیرا ممکن است حاوی بدافزار یا اطلاعات حساس باشد.

4. مکانیزم‌های نظارتی قوی را برای شناسایی تلاش‌ها برای خروج از محیط Honeypot اجرا کنید.

نتیجه گیری

با این کار، ما هانی‌پات خود را ساخته‌ایم، یک شبیه‌ساز برای شبیه‌سازی حملات برای هانی‌پات خود نوشته‌ایم و داده‌های گزارش‌های هانی‌پات خود را تجزیه و تحلیل کرده‌ایم تا چند استنتاج ساده به دست آوریم. این یک راه عالی برای درک مفاهیم امنیتی تهاجمی و دفاعی است. می‌توانید برای ایجاد سیستم‌های تشخیص پیچیده‌تر بر اساس آن فکر کنید و به اضافه کردن ویژگی‌هایی مانند:

1. مبتنی بر شبیه سازی سرویس پویا روی رفتار حمله

2. ادغام با سیستم‌های اطلاعاتی تهدید که تجزیه و تحلیل استنتاج بهتری از این گزارش‌های هانی‌پات جمع‌آوری شده انجام می‌دهد

3. حتی گزارش‌های جامع فراتر از داده‌های IP، پورت و شبکه را از طریق مکانیسم‌های پیشرفته گزارش‌گیری جمع‌آوری کنید

4. قابلیت‌های یادگیری ماشینی را برای شناسایی الگوهای حمله اضافه کنید

به یاد داشته باشید که اگرچه هانی پات ها ابزار امنیتی قدرتمندی هستند، اما باید بخشی از یک استراتژی امنیتی دفاعی جامع باشند، نه تنها خط دفاعی.

امیدوارم با روش کار Honeypot ها، هدف آنها و همچنین کمی برنامه نویسی پایتون آشنا شده باشید!

[*]
[*]منتشر شده در 1403-12-20 00:14:14