في مجال الأمن السيبراني، يُعدّ الـ “هوني بوت” نظام خداع مصمم لجذب ثم اكتشاف المهاجمين المحتملين الذين يحاولون اختراق النظام. تمامًا كما أن وعاء العسل الذي يوضع في العراء يجذب الذباب.
اعتبر هذه الـ “هوني بوتس” ككاميرات أمان لنظامك. تمامًا كما تساعدنا كاميرات الأمان في فهم من يحاول اقتحام مبنى وكيفية قيامهم بذلك، ستساعدك هذه الـ “هوني بوتس” في فهم من يحاول الهجوم على نظامك وما هي التقنيات التي يستخدمونها.
بحلول نهاية هذا الدرس، ستكون قادرًا على كتابة نموذج هوني بوت بلغة بايثون وفهم كيفية عمل الـ “هوني بوتس”.
جدول المحتويات
فهم أنواع الفخاخ الإلكترونية
قبل أن نبدأ في تصميم فخنا الإلكتروني الخاص، دعونا نفهم بسرعة أنواعها المختلفة:
-
فخاخ الإنتاج: تُوضع هذه الأنواع من الفخاخ الإلكترونية في بيئة إنتاج فعلية وتُستخدم لاكتشاف الهجمات الأمنية الفعلية. عادةً ما تكون بسيطة في التصميم، وسهلة الصيانة والنشر، وتقدم تفاعلاً محدوداً لتقليل المخاطر.
-
فخاخ البحث: هذه أنظمة أكثر تعقيدًا تم إعدادها من قبل الباحثين في مجال الأمن لدراسة أنماط الهجمات، وإجراء تحليلات تجريبية على هذه الأنماط، وجمع عينات من البرمجيات الخبيثة، وفهم تقنيات الهجوم الجديدة التي لم يتم اكتشافها سابقًا. غالبًا ما تحاكي أنظمة تشغيل أو شبكات كاملة بدلاً من التصرف كأحد التطبيقات في بيئة الإنتاج.
في هذا الدليل، سنقوم ببناء شهداء تفاعلي متوسط يسجل محاولات الاتصال وسلوك المهاجمين الأساسي.
كيف تقوم بإعداد بيئة التطوير الخاصة بك
لنبدأ بإعداد بيئة التطوير الخاصة بك في بايثون. قم بتشغيل الأوامر التالية:
import socket
import sys
import datetime
import json
import threading
from pathlib import Path
# إعداد دليل التسجيل
LOG_DIR = Path("honeypot_logs")
LOG_DIR.mkdir(exist_ok=True)
سنلتزم بالمكتبات المدمجة لذا لن نحتاج إلى تثبيت أي تبعيات خارجية. سنقوم بتخزين سجلاتنا في دليل honeypot_logs.
كيف نبني قلب الشهداء
سيكون شهيدنا الأساسي مكونًا من ثلاثة عناصر:
-
مستمع شبكة يقبل الاتصالات
-
نظام تسجيل لتوثيق الأنشطة
-
خدمة محاكاة أساسية للتفاعل مع المهاجمين
الآن دعنا نبدأ بتهيئة فئة الشهداء الأساسية:
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] # المنافذ الافتراضية للمراقبة
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:
# إرسال لافتة مناسبة للخدمة
if port in service_banners:
client_socket.send(service_banners[port].encode())
# تلقي البيانات من المهاجم
while True:
data = client_socket.recv(1024)
if not data:
break
self.log_activity(port, remote_ip, data)
# إرسال استجابة وهمية
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 والمنافذ التي سنستضيف عليها الفخ، بالإضافة إلى مسار / اسم ملف سجل الأحداث. سنقوم أيضًا بالحفاظ على سجل لعدد الاتصالات النشطة التي لدينا مع الفخ.
ستقوم دالة log_activity بتلقي المعلومات حول عنوان IP والبيانات والم port الذي حاول عنوان IP الاتصال به. بعد ذلك، سنضيف هذه المعلومات إلى ملف السجل بتنسيق JSON.
ستقوم دالة handle_connection بمحاكاة هذه الخدمات التي ستعمل على المنافذ المختلفة لدينا. سيكون لدينا الفخ يعمل على المنافذ 21 و 22 و 80 و 443. هذه الخدمات مخصصة لـ FTP و SSH و HTTP وبروتوكول HTTPS على التوالي. لذا، يجب على أي مهاجم يحاول التفاعل مع الفخ أن يتوقع هذه الخدمات على هذه المنافذ.
لتمثيل سلوك هذه الخدمات، سنستخدم اللافتات الخاصة بالخدمات كما تستخدم في الواقع. ستقوم هذه الدالة أولاً بإرسال اللافتة المناسبة عندما يتصل المهاجم، ثم تتلقى البيانات وتقوم بتسجيلها. ستقوم الفخ أيضًا بإرسال استجابة وهمية ” الأمر غير معروف ” مرة أخرى إلى المهاجم.
تنفيذ مستمعي الشبكة
الآن دعونا نقوم بتنفيذ مستمعي الشبكة الذين سيتعاملون مع الاتصالات الواردة. سنستخدم في ذلك برمجة سوكيت بسيطة. إذا لم تكن على دراية بكيفية عمل برمجة السوكيت، تحقق من هذه المقالة التي تشرح بعض المفاهيم المتعلقة بذلك.
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]}")
# التعامل مع الاتصال في خيط منفصل
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 ببدء الخادم والاستماع على المنفذ المحدد. ستكون bind_ip لدينا هي 0.0.0.0 مما يشير إلى أن الخادم سيستمع على جميع واجهات الشبكة.
الآن، سنتعامل مع كل اتصال جديد في خيط منفصل، لأنه قد تكون هناك حالات يحاول فيها عدة مهاجمين التفاعل مع الفخ أو يكون هناك سكربت أو أداة هجومية تقوم بمسح الفخ. إذا لم تكن على دراية بكيفية عمل الخيوط، يمكنك تحقق من هذه المقالة التي تشرح الخيوط والتزامن في بايثون.
أيضًا، تأكد من وضع هذه الدالة في فئة Honeypot الأساسية.
تشغيل الفخ
الآن دعونا ننشئ الدالة main التي ستبدأ فخنا.
def main():
honeypot = Honeypot()
# بدء المستمعين لكل منفذ في خيوط منفصلة
for port in honeypot.ports:
listener_thread = threading.Thread(
target=honeypot.start_listener,
args=(port,)
)
listener_thread.daemon = True
listener_thread.start()
try:
# الحفاظ على خيط الرئيس نشطًا
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
الآن دعنا نحاول محاكاة بعض سيناريوهات الهجوم واستهداف الـ honeypot الخاص بنا حتى نتمكن من جمع بعض البيانات في ملف سجل JSON الخاص بنا.
سيساعدنا هذا المحاكي في توضيح بعض الجوانب المهمة حول honeypots:
-
أنماط الهجوم الواقعية: ستحاكي الأداة أنماط الهجوم الشائعة مثل فحص المنافذ، ومحاولات القوة الغاشمة، واستغلالات الخدمة المحددة.
-
شدة متغيرة: ستقوم الأداة بضبط شدة المحاكاة لاختبار كيفية تعامل honeypot الخاص بك مع أحمال مختلفة.
-
عدة أنواع من الهجمات: ستوضح أنواعًا مختلفة من الهجمات التي قد يحاولها المهاجمون الحقيقيون، مما يساعدك على فهم كيفية استجابة 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"):
# إعدادات المحاكي
self.target_ip = target_ip
self.intensity = intensity
# المنافذ الشائعة التي غالبًا ما يستكشفها المهاجمون
self.target_ports = [21, 22, 23, 25, 80, 443, 3306, 5432]
# قاموس للأوامر الشائعة المستخدمة من قبل المهاجمين لخدمات مختلفة
self.attack_patterns = {
21: [ # أوامر FTP
"USER admin\r\n",
"PASS admin123\r\n",
"LIST\r\n",
"STOR malware.exe\r\n"
],
22: [ # محاولات SSH
"SSH-2.0-OpenSSH_7.9\r\n",
"admin:password123\n",
"root:toor\n"
],
80: [ # طلبات HTTP
"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"
]
}
# تؤثر إعدادات الكثافة على تكرار وحجم الهجمات المحاكية
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:
# إنشاء اتصال سوكيت جديد
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 = sock.recv(1024)
print(f"[+] Received banner from port {port}: {banner.decode('utf-8', 'ignore').strip()}")
# إرسال أنماط الهجوم بناءً على المنفذ
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())
# الانتظار للحصول على استجابة
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}")
# إضافة تأخير واقعي بين الأوامر
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:
# مزيج من أنماط الهجوم المختلفة
simulation_choices = [
lambda: self.simulate_port_scan(),
lambda: self.simulate_brute_force(21),
lambda: self.simulate_brute_force(22),
lambda: self.simulate_connection(80)
]
# اختيار وتنفيذ نمط هجوم بشكل عشوائي
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()
لدينا الكثير من الأمور التي تحدث في هذا السكربت المحاكي، لذا دعنا نفصلها واحدة تلو الأخرى. لقد أضفت أيضًا تعليقات لكل دالة وعملية لجعل هذا أكثر وضوحًا في الكود.
لدينا أولاً فئة المرافق الخاصة بنا المسماة HoneypotSimulator. في هذه الفئة، لدينا دالة __init__ التي تقوم بإعداد التكوين الأساسي لمحاكتنا. تأخذ دالتان اثنتان: عنوان IP الهدف (يفتر defaults إلى localhost) ومستوى الشدة (يفتر defaults إلى “متوسط”).
كما نقوم بتعريف ثلاثة مكونات مهمة: المنافذ المستهدفة للفحص (خدمات شائعة مثل FTP، SSH، HTTP)، أنماط الهجوم الخاصة بكل خدمة (مثل محاولات تسجيل الدخول والأوامر)، وإعدادات الشدة التي تتحكم في مدى عدوانية محاكتنا من خلال عدد الخيوط وتأخيرات التوقيت.
تتعامل دالة simulate_connection مع محاولات الاتصال الفردية إلى منفذ محدد. تقوم بإنشاء اتصال بالمقبس، وتحاول الحصول على أي لافتات خدمة (مثل معلومات إصدار SSH)، ثم ترسل أوامر هجوم مناسبة بناءً على نوع الخدمة. لقد أضفنا معالجة الأخطاء لمشكلات الشبكة الشائعة وأضفنا أيضًا تأخيرات واقعية بين الأوامر لمحاكاة التفاعل البشري.
تعمل دالة simulate_port_scan كأداة استكشاف، ستتحقق بشكل منهجي من كل منفذ في قائمة الأهداف لدينا. إنها مشابهة لكيفية عمل أدوات مثل nmap – تمر عبر المنافذ واحدة تلو الأخرى لرؤية الخدمات المتاحة. لكل منفذ، تستدعي دالة simulate_connection وتضيف تأخيرات عشوائية صغيرة لجعل نمط الفحص يبدو أكثر طبيعية.
تقوم دالة simulate_brute_force بالحفاظ على قوائم من أسماء المستخدمين وكلمات المرور الشائعة، محاولاً تجريب تركيبات مختلفة ضد خدمات مثل FTP و SSH. لكل محاولة، تقوم بإنشاء اتصال جديد، وترسل بيانات اعتماد تسجيل الدخول بالشكل الصحيح لتلك الخدمة، ثم تغلق الاتصال. يساعدنا هذا في اختبار مدى جودة اكتشاف سجلات النظام الاحتيالي للهجمات التي تستخدم بيانات اعتماد مكدسة.
تقوم دالة run_continuous_simulation بالتشغيل لمدة محددة، مختارة عشوائياً بين أنواع الهجمات المختلفة مثل فحص المنافذ، القوة الغاشمة، أو هجمات الخدمة المحددة. تستخدم ThreadPoolExecutor من بايثون لتشغيل عدة هجمات في وقت واحد بناءً على مستوى الشدة المحدد.
أخيرًا، لدينا دالة main التي توفر واجهة سطر الأوامر لمحاكي الهجوم. تستخدم argparse للتعامل مع وسائط سطر الأوامر، مما يسمح للمستخدمين بتحديد عنوان IP المستهدف، مستوى الشدة، ومدة المحاكاة. تنشئ مثيلًا لفئة HoneypotSimulator وتدير التنفيذ العام، بما في ذلك التعامل الصحيح مع مقاطعات المستخدم والأخطاء.
بعد وضع كود المحاكي في نص منفصل، قم بتشغيله باستخدام الأمر التالي:
# التشغيل مع الإعدادات الافتراضية (شدة متوسطة، localhost، 5 دقائق)
python honeypot_simulator.py
# التشغيل مع الإعدادات المخصصة
python honeypot_simulator.py --target 192.168.1.100 --intensity high --duration 600
نظرًا لأننا نشغل جهاز الصيد (honeypot) والمحاكي على نفس الجهاز محليًا، سيكون الهدف هو localhost. لكن يمكن أن يكون شيئًا آخر في سيناريو حقيقي أو إذا كنت تشغل جهاز الصيد في آلة افتراضية أو جهاز مختلف – لذا تأكد من تأكيد عنوان الـ IP قبل تشغيل المحاكي.
كيفية تحليل بيانات جهاز الصيد
دعونا نكتب بسرعة دالة مساعدة ستسمح لنا بتحليل جميع البيانات التي تم جمعها بواسطة جهاز الصيد. نظرًا لأننا قمنا بتخزين هذا في ملف سجل بصيغة 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 = {}
# تتبع أنماط الجلسات
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 إذا كان جديدًا
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
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())
# تتبع الأنماط الساعية
hour = timestamp.hour
hourly_attacks[hour] = hourly_attacks.get(hour, 0) + 1
# تحليل أنماط استهداف المنافذ
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())
# تتبع أنماط الحمولة
if data.strip():
data_patterns[data.strip()] = data_patterns.get(data.strip(), 0) + 1
# تتبع جدول الهجمات
attack_timeline.append({
'timestamp': timestamp,
'ip': ip,
'port': port
})
except (json.JSONDecodeError, KeyError) as e:
continue
# توليد تقرير التحليل
print("\n=== Honeypot Analysis Report ===")
# 1. تحليل مستند إلى IP
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. تحليل المنافذ
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. تحليل زمني
print("\nHourly Attack Distribution:")
for hour in sorted(hourly_attacks.keys()):
print(f"Hour {hour:02d}: {hourly_attacks[hour]} attempts")
# 4. تحليل تعقيد الهجمات
print("\nAttacker Sophistication Analysis:")
for ip, stats in sorted_ips:
sophistication_score = (
len(stats['targeted_ports']) * 0.4 + # تنوع المنافذ
len(stats['unique_payloads']) * 0.6 # تنوع الحمولة
)
print(f"IP {ip}: Sophistication Score {sophistication_score:.2f}")
# 5. أنماط الحمولة الشائعة
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: # تقصير الحمولات الطويلة
payload = payload[:50] + "..."
print(f"Count {count}: {payload}")
يمكنك وضع هذا في ملف سكربت منفصل واستدعاء الدالة على سجلات JSON. ستوفر لنا هذه الدالة رؤى شاملة من ملف JSON بناءً على البيانات التي تم جمعها.
تبدأ تحليلاتنا بتجميع البيانات إلى عدة فئات مثل إحصائيات قائمة على IP، وأنماط استهداف المنافذ، وتوزيعات الهجمات على مدار الساعة، وخصائص الحمولة. بالنسبة لكل IP، نحن نتتبع إجمالي المحاولات، وأوقات الظهور الأولى والأخيرة، والمنافذ المستهدفة، والحمولات الفريدة. سيساعدنا هذا في بناء ملفات تعريف فريدة للمهاجمين.
نحن أيضًا ندرس هنا أنماط الهجوم القائمة على المنافذ التي تراقب المنافذ الأكثر استهدافًا، وعدد المهاجمين الفريدين. نقوم أيضًا بإجراء تحليل لتعقيد الهجمات يساعدنا في تحديد المهاجمين المستهدفين، مع الأخذ في الاعتبار عوامل مثل المنافذ المستهدفة والحمولات الفريدة المستخدمة. يستخدم هذا التحليل لفصل أنشطة المسح البسيطة عن الهجمات المتطورة.
يساعدنا التحليل الزمني في تحديد الأنماط في محاولات الهجوم على مدار الساعة مما يكشف الأنماط في توقيت الهجمات وحملات الاستهداف المحتملة الآلية. أخيرًا، ننشر الحمولات الشائعة التي تم رؤيتها لتحديد سلاسل الهجمات أو الأوامر الشائعة.
اعتبارات الأمان
عند نشر هذا الفخ، تأكد من مراعاة تدابير الأمان التالية:
-
قم بتشغيل الفخ في بيئة معزولة. عادةً داخل جهاز افتراضي، أو على جهازك المحلي الذي يقع خلف NAT وجدار ناري.
-
قم بتشغيل الفخ مع الحد الأدنى من امتيازات النظام (عادةً ليس كجذر) لتقليل المخاطر إذا تم اختراقه.
-
كن حذرًا بشأن البيانات التي تم جمعها إذا كنت تخطط يومًا ما لاستخدامها كنقطة جذب إنتاجية أو بحثية، حيث قد تحتوي على برامج ضارة أو معلومات حساسة.
-
قم بتنفيذ آليات مراقبة قوية لاكتشاف محاولات الخروج من بيئة نقطة الجذب.
الخاتمة
بهذا، قمنا ببناء نقطة الجذب الخاصة بنا، وكتبنا محاكيًا لمحاكاة الهجمات على نقطة الجذب الخاصة بنا، وحللنا البيانات من سجلات نقطة الجذب الخاصة بنا للتوصل إلى بعض الاستنتاجات البسيطة. إنها وسيلة ممتازة لفهم مفاهيم الأمن الهجومي والدفاعي على حد سواء. يمكنك التفكير في البناء على ذلك لإنشاء أنظمة كشف أكثر تعقيدًا والتفكير في إضافة ميزات مثل:
-
محاكاة الخدمة الديناميكية بناءً على سلوك الهجوم
-
التكامل مع أنظمة استخبارات التهديدات التي ستقوم بتحليل استنتاجات أفضل من سجلات نقطة الجذب المجمعة هذه
-
جمع سجلات شاملة تتجاوز عناوين IP، والمنافذ، وبيانات الشبكة من خلال آليات تسجيل متقدمة
-
إضافة قدرات التعلم الآلي لاكتشاف أنماط الهجوم
تذكر أنه على الرغم من أن الفخاخ الإلكترونية أدوات أمان قوية، إلا أنه يجب أن تكون جزءًا من استراتيجية أمان دفاعية شاملة، وليس الخط الدفاعي الوحيد.
آمل أن تكون قد تعلمت كيف تعمل الفخاخ الإلكترونية، وما هو هدفها، بالإضافة إلى بعض برمجة بايثون أيضًا!
Source:
https://www.freecodecamp.org/news/build-a-honeypot-with-python/