محقق الطب الشرعي الرقمي - جمع الأدلة الرقمية وتحليلها

فيديوهات تعليمية

ما هو محقق الطب الشرعي الرقمي؟

باحث الأدلة الرقمية

محقق الطب الشرعي الرقمي يركز على جمع الأدلة الرقمية وتحليلها باستخدام أدوات مثل FTK Imager و Splunk، بهدف حل القضايا الجنائية وتحقيق العدالة.

جمع الأدلة

تجمع وتحفظ الأدلة الرقمية بشكل قانوني

تحليل الأدلة

فحص البيانات والملفات والاتصالات

التقارير

إنشاء تقارير مفصلة للسلطات القانونية

إثبات الأدلة

تقديم الأدلة في المحاكم بشكل مقبول قانونياً

اللغات والأدوات المستخدمة

Python

اللغة الأساسية للتعامل مع البيانات وتحليل النماذج

Shell Scripting

لأتمتة العمليات في أنظمة Linux/Unix

NoSQL/Hive

قواعد البيانات غير العلائقية لتحليل البيانات

JSON/YAML

تكوين ملفات الإعدادات والمعلمات

Markdown

إنشاء تقارير واضحة ومفصلة

Jupyter Notebook

توثيق التحليلات بشكل تفاعلي

مهارات محقق الطب الشرعي الرقمي

1

جمع الأدلة الرقمية

استخدام FTK Imager و Autopsy لجمع الأدلة

2

استعادة الملفات

استخدام TestDisk و PhotoRec لاستعادة البيانات

3

تحليل السجلات

استخدام Splunk و ELK Stack لتحليل السجلات

4

الأدوات الرقمية

FTK Imager، Autopsy، TestDisk، PhotoRec

5

تحليل الأدلة

فحص البيانات والملفات والاتصالات الرقمية

6

إعداد التقارير

إنشاء تقارير مفصلة للسلطات القانونية

خارطة التعلم خطوة بخطوة

1

الخطوة 1: تعلم جمع الأدلة الرقمية

جمع الأدلة الرقمية هو عملية جمع الأدلة الرقمية من الأجهزة مثل الهواتف الذكية، الحواسيب، والأقراص الصلبة. يتم استخدام هذه الأدلة في التحقيقات الجنائية.

الأهمية:

الأساس لفهم كيفية جمع الأدلة الرقمية بطريقة قانونية وموثوقة

الأدوات:

FTK Imager، Autopsy

أمثلة جمع الأدلة:

# ===== جمع الأدلة الرقمية باستخدام FTK Imager =====

# 1. إنشاء صورة قرص باستخدام FTK Imager
# خطوات استخدام واجهة المستخدم:
# File > Create Disk Image > Select Source > Save Image

# 2. سكربت bash لأتمتة جمع الأدلة
cat > collect_evidence.sh << 'EOF'
#!/bin/bash
# سكربت جمع الأدلة الرقمية

echo "بدء عملية جمع الأدلة الرقمية..."
echo "=================================="

# معلومات النظام
echo "1. جمع معلومات النظام:"
uname -a > system_info.txt
lsb_release -a >> system_info.txt
echo "تم حفظ معلومات النظام في system_info.txt"

# معلومات المستخدمين
echo "2. جمع معلومات المستخدمين:"
cat /etc/passwd > users_info.txt
cat /etc/group >> users_info.txt
echo "تم حفظ معلومات المستخدمين في users_info.txt"

# العمليات الجارية
echo "3. جمع معلومات العمليات:"
ps aux > processes.txt
netstat -tulpn > network_connections.txt
echo "تم حفظ معلومات العمليات في processes.txt"

# السجلات
echo "4. جمع السجلات المهمة:"
mkdir -p logs
cp /var/log/auth.log logs/
cp /var/log/syslog logs/
cp /var/log/kern.log logs/
cp /var/log/apache2/access.log logs/ 2>/dev/null || true
cp /var/log/apache2/error.log logs/ 2>/dev/null || true

# معلومات القرص
echo "5. جمع معلومات القرص:"
df -h > disk_usage.txt
fdisk -l > disk_partitions.txt
lsblk > block_devices.txt
echo "تم حفظ معلومات القرص في ملفات منفصلة"

# إنشاء هاش للأدلة
echo "6. إنشاء هاش للأدلة:"
find . -type f -exec sha256sum {} \; > evidence_hashes.txt
echo "تم إنشاء هاش SHA256 لكل ملف"

# ضغط الأدلة
echo "7. ضغط الأدلة:"
timestamp=$(date +%Y%m%d_%H%M%S)
tar -czf evidence_$timestamp.tar.gz *.txt logs/
echo "تم ضغط الأدلة في evidence_$timestamp.tar.gz"

# حساب هاش الأرشيف
sha256sum evidence_$timestamp.tar.gz > evidence_hash.txt
echo "تم حساب هاش الأرشيف:"
cat evidence_hash.txt

echo "تم الانتهاء من جمع الأدلة!"
EOF

chmod +x collect_evidence.sh
sudo ./collect_evidence.sh

# 3. برنامج Python لجمع الأدلة
import hashlib
import os
import json
from datetime import datetime

class DigitalEvidenceCollector:
    def __init__(self, case_number, investigator):
        self.case_number = case_number
        self.investigator = investigator
        self.evidence = {
            'metadata': {},
            'files': [],
            'timeline': [],
            'hashes': {}
        }
        
    def collect_system_info(self):
        """جمع معلومات النظام"""
        import platform
        import socket
        
        self.evidence['metadata']['system'] = {
            'hostname': socket.gethostname(),
            'os': platform.system(),
            'os_version': platform.version(),
            'processor': platform.processor(),
            'architecture': platform.architecture()[0]
        }
        
        # إضافة إلى الجدول الزمني
        self.evidence['timeline'].append({
            'timestamp': datetime.now().isoformat(),
            'action': 'collected_system_info',
            'description': 'جمع معلومات النظام الأساسية'
        })
        
        return self.evidence['metadata']['system']
    
    def hash_file(self, file_path):
        """إنشاء هاش للملف"""
        hash_sha256 = hashlib.sha256()
        
        try:
            with open(file_path, 'rb') as f:
                for chunk in iter(lambda: f.read(4096), b""):
                    hash_sha256.update(chunk)
            
            file_hash = hash_sha256.hexdigest()
            self.evidence['hashes'][file_path] = file_hash
            
            return file_hash
        except Exception as e:
            print(f"خطأ في حساب هاش الملف {file_path}: {e}")
            return None
    
    def collect_evidence_files(self, directory, extensions=None):
        """جمع الملفات كأدلة"""
        evidence_files = []
        
        for root, dirs, files in os.walk(directory):
            for file in files:
                if extensions:
                    if any(file.endswith(ext) for ext in extensions):
                        file_path = os.path.join(root, file)
                        evidence_files.append(file_path)
                else:
                    file_path = os.path.join(root, file)
                    evidence_files.append(file_path)
        
        # حساب الهاش للملفات
        for file_path in evidence_files[:10]:  # أول 10 ملفات كمثال
            file_hash = self.hash_file(file_path)
            
            self.evidence['files'].append({
                'path': file_path,
                'hash': file_hash,
                'size': os.path.getsize(file_path),
                'modified': datetime.fromtimestamp(os.path.getmtime(file_path)).isoformat()
            })
        
        return evidence_files
    
    def analyze_logs(self, log_file):
        """تحليل سجلات النظام"""
        suspicious_patterns = [
            'Failed password',
            'Invalid user',
            'authentication failure',
            'unauthorized',
            'access denied',
            'malware',
            'virus detected'
        ]
        
        findings = []
        
        try:
            with open(log_file, 'r', encoding='utf-8', errors='ignore') as f:
                lines = f.readlines()
                
                for i, line in enumerate(lines):
                    for pattern in suspicious_patterns:
                        if pattern.lower() in line.lower():
                            findings.append({
                                'line_number': i + 1,
                                'pattern': pattern,
                                'content': line.strip(),
                                'timestamp': datetime.now().isoformat()
                            })
        except Exception as e:
            print(f"خطأ في قراءة ملف السجل {log_file}: {e}")
        
        return findings
    
    def generate_report(self):
        """إنشاء تقرير الأدلة"""
        report = {
            'case_number': self.case_number,
            'investigator': self.investigator,
            'collection_date': datetime.now().isoformat(),
            'evidence_summary': {
                'total_files': len(self.evidence['files']),
                'total_hashes': len(self.evidence['hashes']),
                'timeline_entries': len(self.evidence['timeline'])
            },
            'system_info': self.evidence['metadata'].get('system', {}),
            'suspicious_findings': [],
            'chain_of_custody': self.evidence['timeline']
        }
        
        # حفظ التقرير
        report_filename = f"digital_evidence_report_{self.case_number}.json"
        with open(report_filename, 'w', encoding='utf-8') as f:
            json.dump(report, f, indent=2, ensure_ascii=False)
        
        print(f"تم إنشاء تقرير الأدلة: {report_filename}")
        return report_filename

# تشغيل المجمع
if __name__ == "__main__":
    print("بدء جمع الأدلة الرقمية...")
    print("=" * 40)
    
    collector = DigitalEvidenceCollector(
        case_number="CASE-2024-001",
        investigator="محقق رقمي"
    )
    
    # جمع معلومات النظام
    system_info = collector.collect_system_info()
    print("✅ معلومات النظام:")
    for key, value in system_info.items():
        print(f"   {key}: {value}")
    
    # جمع ملفات الأدلة
    print("\n🔍 جمع ملفات الأدلة...")
    evidence_files = collector.collect_evidence_files(
        directory="/var/log",
        extensions=[".log", ".txt"]
    )
    print(f"✅ تم جمع {len(evidence_files)} ملف كأدلة")
    
    # تحليل السجلات
    print("\n📊 تحليل سجلات النظام...")
    log_findings = collector.analyze_logs("/var/log/auth.log")
    print(f"✅ تم العثور على {len(log_findings)} نشاط مشبوه")
    
    # إنشاء التقرير
    print("\n📄 إنشاء تقرير الأدلة...")
    report_file = collector.generate_report()
    print(f"✅ تم حفظ التقرير في: {report_file}")
    
    print("\n" + "=" * 40)
    print("✅ اكتمل جمع الأدلة الرقمية بنجاح")

# 4. أوامر Linux لجمع الأدلة
echo "أمثلة أوامر جمع الأدلة:"

# جمع معلومات النظام
uname -a
cat /etc/os-release
hostnamectl

# جمع معلومات الشبكة
ip addr show
netstat -tulpn
ss -tulpn

# جمع معلومات المستخدمين
cat /etc/passwd
cat /etc/group
last
lastlog

# جمع معلومات القرص
df -h
lsblk
fdisk -l

# جمع السجلات
journalctl -xe
dmesg | tail -50
cat /var/log/syslog | tail -100

# حساب هاش الملفات
sha256sum important_file.txt
md5sum evidence_file.bin

# البحث عن ملفات معينة
find / -name "*.conf" -type f 2>/dev/null
find / -perm -4000 -type f 2>/dev/null  # ملفات SUID

# إنشاء صورة للقرص
# dd if=/dev/sda of=disk_image.img bs=4M status=progress

2

الخطوة 2: تعلم استعادة الملفات

استعادة الملفات هو عملية استعادة الملفات المحذوفة أو التالفة من الأجهزة. يستخدم لاستعادة البيانات المفقودة بسبب الحوادث أو الهجمات السيبرانية.

الأهمية:

ضروري لفهم كيفية استعادة البيانات المهمة واستخدامها كدليل رقمي

الأدوات:

TestDisk، PhotoRec

أمثلة استعادة الملفات:

# ===== استعادة الملفات باستخدام TestDisk و PhotoRec =====

# 1. استخدام TestDisk لاستعادة الملفات المحذوفة
echo "1. استعادة الملفات باستخدام TestDisk:"

# بدء TestDisk
# sudo testdisk

# خطوات TestDisk:
# 1. Create a new log file
# 2. Select disk (e.g., /dev/sda)
# 3. Select partition table type (usually Intel)
# 4. Choose [Analyse] > [Quick Search]
# 5. Select partition > [Type] to change filesystem type if needed
# 6. Choose [Advanced] > [Undelete]
# 7. Select files to recover > Copy to safe location

# 2. استخدام PhotoRec لاستعادة البيانات
echo "2. استعادة البيانات باستخدام PhotoRec:"

# بدء PhotoRec
# sudo photorec

# خطوات PhotoRec:
# 1. Select disk
# 2. Choose partition
# 3. Select filesystem (FAT, NTFS, ext2/ext3/ext4)
# 4. Choose file types to recover
# 5. Select destination folder
# 6. Start recovery

# 3. سكربت bash لأتمتة استعادة الملفات
cat > file_recovery.sh << 'EOF'
#!/bin/bash
# سكربت استعادة الملفات المتقدمة

echo "بدء عملية استعادة الملفات..."
echo "============================="

RECOVERY_DIR="recovered_files_$(date +%Y%m%d_%H%M%S)"
mkdir -p "$RECOVERY_DIR"

# 1. البحث عن الملفات المحذوفة حديثاً
echo "1. البحث عن الملفات المحذوفة..."
deleted_files=$(find / -type f -name "*.tmp" -o -name "*.bak" -o -name "*.old" 2>/dev/null | head -20)

if [ -n "$deleted_files" ]; then
    echo "✅ تم العثور على ملفات محذوفة محتملة:"
    echo "$deleted_files" | head -5
else
    echo "❌ لم يتم العثور على ملفات محذوفة"
fi

# 2. استعادة ملفات السجل
echo -e "\n2. استعادة ملفات السجل..."
log_files=(
    "/var/log/auth.log"
    "/var/log/syslog"
    "/var/log/kern.log"
    "/var/log/dmesg"
)

for log_file in "${log_files[@]}"; do
    if [ -f "$log_file" ]; then
        cp "$log_file" "$RECOVERY_DIR/"
        echo "   ✅ تم نسخ: $(basename $log_file)"
    fi
done

# 3. استعادة ملفات التكوين
echo -e "\n3. استعادة ملفات التكوين..."
config_files=$(find /etc -name "*.conf" -type f 2>/dev/null | head -10)
for config in $config_files; do
    cp "$config" "$RECOVERY_DIR/"
    echo "   ✅ تم نسخ: $(basename $config)"
done

# 4. البحث عن ملفات مؤقتة
echo -e "\n4. البحث عن الملفات المؤقتة..."
temp_dirs=("/tmp" "/var/tmp" "~/.cache" "~/.local/share/Trash")
for temp_dir in "${temp_dirs[@]}"; do
    if [ -d "$temp_dir" ]; then
        find "$temp_dir" -type f -mtime -7 2>/dev/null | head -5 | while read file; do
            rel_path=$(echo "$file" | sed 's|/|_|g')
            cp "$file" "$RECOVERY_DIR/temp_${rel_path##*_}"
        done
    fi
done

# 5. إنشاء قائمة بالملفات المستعادة
echo -e "\n5. إنشاء قائمة الملفات المستعادة..."
find "$RECOVERY_DIR" -type f > "$RECOVERY_DIR/recovery_list.txt"
file_count=$(wc -l < "$RECOVERY_DIR/recovery_list.txt")

# 6. حساب هاش الملفات المستعادة
echo -e "\n6. حساب هاش الملفات..."
find "$RECOVERY_DIR" -type f -exec sha256sum {} \; > "$RECOVERY_DIR/file_hashes.txt"

echo -e "\n✅ تم استعادة $file_count ملف"
echo "   المجلد: $RECOVERY_DIR"
echo "   قائمة الملفات: $RECOVERY_DIR/recovery_list.txt"
echo "   هاش الملفات: $RECOVERY_DIR/file_hashes.txt"
EOF

chmod +x file_recovery.sh
sudo ./file_recovery.sh

# 4. برنامج Python لاستعادة الملفات
import os
import shutil
import hashlib
from datetime import datetime, timedelta

class FileRecoveryTool:
    def __init__(self, recovery_path="recovered_data"):
        self.recovery_path = recovery_path
        self.recovered_files = []
        
        if not os.path.exists(recovery_path):
            os.makedirs(recovery_path)
    
    def recover_deleted_files_by_signature(self, disk_path, signatures):
        """استعادة الملفات باستخدام التوقيعات"""
        print(f"البحث عن ملفات على {disk_path} باستخدام التوقيعات...")
        
        # توقيعات الملفات الشائعة (magic numbers)
        file_signatures = {
            'jpg': b'\xFF\xD8\xFF',
            'png': b'\x89\x50\x4E\x47',
            'pdf': b'\x25\x50\x44\x46',
            'zip': b'\x50\x4B\x03\x04',
            'doc': b'\xD0\xCF\x11\xE0',
            'exe': b'\x4D\x5A'
        }
        
        recovered = []
        
        try:
            with open(disk_path, 'rb') as disk:
                # قراءة القرص في قطع
                chunk_size = 4096
                offset = 0
                
                while True:
                    chunk = disk.read(chunk_size)
                    if not chunk:
                        break
                    
                    # البحث عن التوقيعات
                    for file_type, signature in file_signatures.items():
                        if signature in chunk:
                            # استخراج الملف
                            sig_index = chunk.find(signature)
                            if sig_index != -1:
                                # حساب موقع بداية الملف
                                file_start = offset + sig_index
                                
                                # محاولة استخراج الملف
                                recovered_file = self.extract_file(
                                    disk_path, 
                                    file_start, 
                                    file_type
                                )
                                
                                if recovered_file:
                                    recovered.append(recovered_file)
                    
                    offset += chunk_size
                    
        except Exception as e:
            print(f"خطأ في قراءة القرص: {e}")
        
        return recovered
    
    def extract_file(self, disk_path, start_offset, file_type):
        """استخراج ملف من القرص"""
        try:
            # تحديد نهاية الملف (هذه طريقة مبسطة)
            file_sizes = {
                'jpg': 1024 * 100,  # 100KB متوسط
                'png': 1024 * 200,  # 200KB متوسط
                'pdf': 1024 * 500,  # 500KB متوسط
                'doc': 1024 * 300,  # 300KB متوسط
            }
            
            file_size = file_sizes.get(file_type, 1024 * 100)  # افتراضي 100KB
            
            with open(disk_path, 'rb') as disk:
                disk.seek(start_offset)
                file_data = disk.read(file_size)
            
            # حفظ الملف المسترجع
            filename = f"recovered_{start_offset:08x}.{file_type}"
            filepath = os.path.join(self.recovery_path, filename)
            
            with open(filepath, 'wb') as f:
                f.write(file_data)
            
            # حساب الهاش
            file_hash = hashlib.sha256(file_data).hexdigest()
            
            self.recovered_files.append({
                'filename': filename,
                'path': filepath,
                'size': len(file_data),
                'hash': file_hash,
                'type': file_type,
                'offset': start_offset
            })
            
            print(f"✅ تم استعادة: {filename} ({len(file_data)} bytes)")
            return filepath
            
        except Exception as e:
            print(f"خطأ في استخراج الملف: {e}")
            return None
    
    def recover_recent_files(self, directories, days=7):
        """استعادة الملفات المعدلة مؤخراً"""
        print(f"البحث عن الملفات المعدلة خلال {days} أيام...")
        
        recovered = []
        cutoff_time = datetime.now() - timedelta(days=days)
        
        for directory in directories:
            if os.path.exists(directory):
                for root, dirs, files in os.walk(directory):
                    for file in files:
                        filepath = os.path.join(root, file)
                        
                        try:
                            mtime = datetime.fromtimestamp(os.path.getmtime(filepath))
                            
                            if mtime > cutoff_time:
                                # نسخ الملف
                                rel_path = os.path.relpath(filepath, directory)
                                dest_path = os.path.join(
                                    self.recovery_path, 
                                    "recent", 
                                    rel_path
                                )
                                
                                os.makedirs(os.path.dirname(dest_path), exist_ok=True)
                                shutil.copy2(filepath, dest_path)
                                
                                recovered.append({
                                    'original': filepath,
                                    'recovered': dest_path,
                                    'modified': mtime.isoformat(),
                                    'size': os.path.getsize(filepath)
                                })
                                
                        except Exception as e:
                            continue
        
        return recovered
    
    def analyze_recovered_files(self):
        """تحليل الملفات المستعادة"""
        print("\nتحليل الملفات المستعادة...")
        
        analysis = {
            'total_files': len(self.recovered_files),
            'by_type': {},
            'total_size': 0,
            'suspicious_files': []
        }
        
        suspicious_keywords = [
            'pass', 'secret', 'confidential',
            'bank', 'credit', 'password',
            'admin', 'root', 'key', 'token'
        ]
        
        for file_info in self.recovered_files:
            # إحصاء حسب النوع
            file_type = file_info['type']
            analysis['by_type'][file_type] = analysis['by_type'].get(file_type, 0) + 1
            
            # جمع الحجم الكلي
            analysis['total_size'] += file_info.get('size', 0)
            
            # البحث عن ملفات مشبوهة
            try:
                with open(file_info['path'], 'rb') as f:
                    content = f.read(1024)  # قراءة أول 1KB
                    
                    for keyword in suspicious_keywords:
                        if keyword.encode() in content.lower():
                            analysis['suspicious_files'].append({
                                'file': file_info['filename'],
                                'keyword': keyword,
                                'path': file_info['path']
                            })
                            break
                            
            except:
                pass
        
        return analysis
    
    def generate_recovery_report(self):
        """إنشاء تقرير الاستعادة"""
        print("\nإنشاء تقرير الاستعادة...")
        
        analysis = self.analyze_recovered_files()
        
        report = {
            'recovery_date': datetime.now().isoformat(),
            'recovery_path': os.path.abspath(self.recovery_path),
            'summary': analysis,
            'recovered_files': self.recovered_files,
            'chain_of_custody': [
                {
                    'timestamp': datetime.now().isoformat(),
                    'action': 'recovery_completed',
                    'details': f"تم استعادة {analysis['total_files']} ملف"
                }
            ]
        }
        
        # حفظ التقرير
        report_file = os.path.join(self.recovery_path, "recovery_report.json")
        import json
        with open(report_file, 'w', encoding='utf-8') as f:
            json.dump(report, f, indent=2, ensure_ascii=False)
        
        print(f"✅ تم حفظ تقرير الاستعادة في: {report_file}")
        return report_file

# تشغيل أداة الاستعادة
if __name__ == "__main__":
    print("بدء أداة استعادة الملفات الرقمية")
    print("=" * 40)
    
    # إنشاء أداة الاستعادة
    recovery = FileRecoveryTool("digital_recovery_evidence")
    
    # استعادة الملفات المعدلة حديثاً
    print("\n1. استعادة الملفات المعدلة حديثاً:")
    recent_dirs = ["/etc", "/var/log", "/tmp"]
    recent_files = recovery.recover_recent_files(recent_dirs, days=3)
    print(f"✅ تم استعادة {len(recent_files)} ملف معدل حديثاً")
    
    # محاولة استعادة باستخدام التوقيعات (محاكاة)
    print("\n2. البحث عن ملفات محذوفة باستخدام التوقيعات:")
    # في الواقع، ستكون disk_path مثل "/dev/sda1"
    # signatures = recovery.recover_deleted_files_by_signature("/dev/sda1", {})
    
    # إنشاء تقرير
    print("\n3. إنشاء تقرير الاستعادة:")
    report = recovery.generate_recovery_report()
    
    # عرض ملخص
    analysis = recovery.analyze_recovered_files()
    print("\n" + "=" * 40)
    print("ملخص الاستعادة:")
    print(f"   • إجمالي الملفات: {analysis['total_files']}")
    print(f"   • الحجم الكلي: {analysis['total_size']:,} بايت")
    print(f"   • الملفات المشبوهة: {len(analysis['suspicious_files'])}")
    
    if analysis['suspicious_files']:
        print("\n   ⚠️  الملفات المشبوهة:")
        for suspicious in analysis['suspicious_files'][:3]:
            print(f"     - {suspicious['file']} ({suspicious['keyword']})")
    
    print("\n✅ اكتملت عملية استعادة الملفات")

# 5. أوامر Linux لاستعادة الملفات
echo "أمثلة أوامر استعادة الملفات:"

# البحث عن الملفات المحذوفة
grep -a "keyword" /dev/sda1 | head -20

# استعادة سجلات النظام
cp /var/log/auth.log ./recovered/
cp /var/log/syslog ./recovered/

# إنشاء صورة للذاكرة
# dd if=/dev/mem of=memory_dump.img bs=1M

# تحليل الملفات الثنائية
strings deleted_file.bin | grep -i "password\|user\|admin"

# فحص الملفات المؤقتة
find /tmp -type f -mtime -1 2>/dev/null
find /var/tmp -type f -size +1M 2>/dev/null

# حساب هاش الملفات المستعادة
find recovered_files -type f -exec sha256sum {} \; > recovered_hashes.txt

echo "تم تعلم استعادة الملفات بنجاح!"

3

الخطوة 3: تعلم تحليل السجلات

تحليل السجلات هو عملية تحليل السجلات (Logs) لاكتشاف الأنشطة المشبوهة أو غير المصرح بها. يتم استخدامه لاكتشاف الهجمات السيبرانية أو تتبع الأنشطة غير القانونية.

الأهمية:

ضروري لفهم كيفية اكتشاف التهديدات ومنع الهجمات المستقبلية

الأدوات:

Splunk، ELK Stack

أمثلة تحليل السجلات:

# ===== تحليل السجلات باستخدام Splunk و ELK Stack =====

# 1. استعلامات Splunk للتحقيقات الرقمية
echo "1. استعلامات Splunk للتحقيقات الرقمية:"

# اكتشاف محاولات تسجيل الدخول الفاشلة
echo "استعلام لتسجيلات الدخول الفاشلة:"
echo 'index=main sourcetype=secure "Failed password" | stats count by src_ip, user'

# اكتشاف نشاط غير عادي
echo "استعلام للنشاط غير العادي:"
echo 'index=main sourcetype=web_access status=404 | top 10 uri'

# تتبع نشاط المستخدم
echo "استعلام لتتبع نشاط المستخدم:"
echo 'index=main user=admin | reverse | table _time, action, src_ip, dest_ip'

# اكتشاف البرمجيات الخبيثة
echo "استعلام للكشف عن البرمجيات الخبيثة:"
echo 'index=main "malware" OR "virus" OR "trojan" | stats count by src_ip, dest_ip'

# 2. استعلامات ELK Stack (Kibana)
echo -e "\n2. استعلامات ELK Stack للتحقيقات الرقمية:"

# استعلام Elasticsearch لاكتشاف الهجمات
echo "استعلام Elasticsearch:"
echo 'GET /logs-*/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "event.action": "login_failed" } },
        { "range": { "@timestamp": { "gte": "now-24h" } } }
      ]
    }
  },
  "aggs": {
    "failed_by_ip": {
      "terms": { "field": "source.ip.keyword", "size": 10 }
    }
  }
}'

# 3. سكربت Python لتحليل السجلات المتقدم
import re
import json
from datetime import datetime, timedelta
from collections import Counter, defaultdict

class LogAnalyzer:
    def __init__(self):
        self.findings = []
        self.suspicious_ips = set()
        self.patterns = {
            'failed_login': r'Failed password for (\S+) from (\S+)',
            'invalid_user': r'Invalid user (\S+) from (\S+)',
            'brute_force': r'POSSIBLE BREAK-IN ATTEMPT',
            'port_scan': r'port scan',
            'malware': r'(malware|virus|trojan|ransomware)',
            'data_exfiltration': r'(upload|download).*(sensitive|confidential)'
        }
    
    def analyze_auth_log(self, log_file):
        """تحليل سجلات المصادقة"""
        print(f"تحليل سجلات المصادقة: {log_file}")
        
        findings = {
            'failed_logins': [],
            'invalid_users': [],
            'suspicious_ips': [],
            'timeline': []
        }
        
        try:
            with open(log_file, 'r', encoding='utf-8', errors='ignore') as f:
                for line_num, line in enumerate(f, 1):
                    line = line.strip()
                    
                    # اكتشاف محاولات تسجيل دخول فاشلة
                    failed_match = re.search(self.patterns['failed_login'], line)
                    if failed_match:
                        user, ip = failed_match.groups()
                        findings['failed_logins'].append({
                            'line': line_num,
                            'user': user,
                            'ip': ip,
                            'timestamp': self.extract_timestamp(line),
                            'raw': line[:100] + '...' if len(line) > 100 else line
                        })
                        
                        if ip not in self.suspicious_ips:
                            self.suspicious_ips.add(ip)
                    
                    # اكتشاف مستخدمين غير صالحين
                    invalid_match = re.search(self.patterns['invalid_user'], line)
                    if invalid_match:
                        user, ip = invalid_match.groups()
                        findings['invalid_users'].append({
                            'line': line_num,
                            'user': user,
                            'ip': ip,
                            'timestamp': self.extract_timestamp(line),
                            'raw': line[:100] + '...' if len(line) > 100 else line
                        })
                    
                    # اكتشاف محاولات اختراق
                    if 'POSSIBLE BREAK-IN ATTEMPT' in line:
                        findings['suspicious_ips'].append({
                            'line': line_num,
                            'type': 'break_in_attempt',
                            'ip': self.extract_ip(line),
                            'timestamp': self.extract_timestamp(line),
                            'raw': line[:100] + '...' if len(line) > 100 else line
                        })
                    
                    # إنشاء جدول زمني
                    timestamp = self.extract_timestamp(line)
                    if timestamp:
                        findings['timeline'].append({
                            'timestamp': timestamp,
                            'event': self.classify_event(line),
                            'line': line_num
                        })
        
        except Exception as e:
            print(f"خطأ في تحليل ملف السجل: {e}")
        
        return findings
    
    def extract_timestamp(self, log_line):
        """استخراج الطابع الزمني من سجل"""
        # أنماط الطوابع الزمنية الشائعة
        patterns = [
            r'(\w{3}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2})',  # Jan  1 12:00:00
            r'(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})',  # ISO 8601
            r'(\d{2}/\d{2}/\d{4}\s+\d{2}:\d{2}:\d{2})' # MM/DD/YYYY HH:MM:SS
        ]
        
        for pattern in patterns:
            match = re.search(pattern, log_line)
            if match:
                return match.group(1)
        
        return None
    
    def extract_ip(self, log_line):
        """استخراج عنوان IP من السجل"""
        ip_pattern = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'
        match = re.search(ip_pattern, log_line)
        return match.group(0) if match else 'Unknown'
    
    def classify_event(self, log_line):
        """تصنيف الحدث بناءً على محتوى السجل"""
        if 'Failed password' in log_line:
            return 'failed_login'
        elif 'Invalid user' in log_line:
            return 'invalid_user'
        elif 'Accepted password' in log_line:
            return 'successful_login'
        elif 'session opened' in log_line:
            return 'session_opened'
        elif 'session closed' in log_line:
            return 'session_closed'
        elif 'error' in log_line.lower():
            return 'error'
        else:
            return 'other'
    
    def analyze_web_logs(self, log_file):
        """تحليل سجلات الويب"""
        print(f"تحليل سجلات الويب: {log_file}")
        
        findings = {
            'suspicious_requests': [],
            'failed_requests': [],
            'attack_patterns': [],
            'statistics': defaultdict(int)
        }
        
        attack_patterns = {
            'sql_injection': r"('|%27|--|union|select|insert|update|delete|drop)",
            'xss': r"( 200 else line
                        })
        
        except Exception as e:
            print(f"خطأ في تحليل سجلات الويب: {e}")
        
        return findings
    
    def generate_forensics_report(self, auth_findings, web_findings):
        """إنشاء تقرير الطب الشرعي الرقمي"""
        print("إنشاء تقرير الطب الشرعي الرقمي...")
        
        report = {
            'report_date': datetime.now().isoformat(),
            'analyst': 'محقق الطب الشرعي الرقمي',
            'executive_summary': {
                'total_failed_logins': len(auth_findings['failed_logins']),
                'total_invalid_users': len(auth_findings['invalid_users']),
                'total_suspicious_ips': len(auth_findings['suspicious_ips']),
                'total_web_attacks': len(web_findings['attack_patterns']),
                'total_suspicious_requests': len(web_findings['suspicious_requests'])
            },
            'detailed_findings': {
                'authentication_logs': auth_findings,
                'web_logs': web_findings
            },
            'recommendations': [],
            'suspicious_entities': list(self.suspicious_ips)[:10]
        }
        
        # إضافة توصيات بناءً على النتائج
        if auth_findings['failed_logins']:
            report['recommendations'].append(
                "توصية: تنفيذ تأكيد متعدد العوامل (MFA) للمستخدمين"
            )
        
        if auth_findings['suspicious_ips']:
            report['recommendations'].append(
                "توصية: حظر عناوين IP المشبوهة في جدار الحماية"
            )
        
        if web_findings['attack_patterns']:
            report['recommendations'].append(
                "توصية: تحديث نظام منع الاختراق (WAF) وتطبيق قواعد أمان"
            )
        
        # حفظ التقرير
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        report_file = f"digital_forensics_report_{timestamp}.json"
        
        with open(report_file, 'w', encoding='utf-8') as f:
            json.dump(report, f, indent=2, ensure_ascii=False)
        
        print(f"✅ تم حفظ التقرير في: {report_file}")
        return report_file

# تشغيل محلل السجلات
if __name__ == "__main__":
    print("بدء تحليل السجلات الرقمية")
    print("=" * 50)
    
    analyzer = LogAnalyzer()
    
    # تحليل سجلات المصادقة
    print("\n1. تحليل سجلات المصادقة:")
    auth_findings = analyzer.analyze_auth_log("/var/log/auth.log")
    
    print(f"   • محاولات تسجيل دخول فاشلة: {len(auth_findings['failed_logins'])}")
    print(f"   • مستخدمين غير صالحين: {len(auth_findings['invalid_users'])}")
    print(f"   • عناوين IP مشبوهة: {len(auth_findings['suspicious_ips'])}")
    
    # تحليل سجلات الويب
    print("\n2. تحليل سجلات الويب:")
    web_findings = analyzer.analyze_web_logs("/var/log/apache2/access.log")
    
    print(f"   • طلبات فاشلة: {len(web_findings['failed_requests'])}")
    print(f"   • أنماط هجوم: {len(web_findings['attack_patterns'])}")
    print(f"   • طلبات مشبوهة: {len(web_findings['suspicious_requests'])}")
    
    # إنشاء التقرير
    print("\n3. إنشاء تقرير الطب الشرعي:")
    report_file = analyzer.generate_forensics_report(auth_findings, web_findings)
    
    # عرض ملخص
    print("\n" + "=" * 50)
    print("ملخص النتائج:")
    
    if auth_findings['failed_logins']:
        print("⚠️  محاولات تسجيل دخول فاشلة متعددة")
        for login in auth_findings['failed_logins'][:3]:
            print(f"   - {login['user']} من {login['ip']}")
    
    if auth_findings['suspicious_ips']:
        print("⚠️  أنشطة مشبوهة من عناوين IP:")
        for ip_info in auth_findings['suspicious_ips'][:3]:
            print(f"   - {ip_info['ip']}: {ip_info['type']}")
    
    if web_findings['attack_patterns']:
        print("⚠️  أنماط هجوم مكتشفة:")
        attacks_by_type = {}
        for attack in web_findings['attack_patterns']:
            attacks_by_type[attack['type']] = attacks_by_type.get(attack['type'], 0) + 1
        
        for attack_type, count in attacks_by_type.items():
            print(f"   - {attack_type}: {count}")
    
    print("\n✅ اكتمل تحليل السجلات الرقمية")

# 4. أوامر Linux لتحليل السجلات
echo "أمثلة أوامر تحليل السجلات:"

# تحليل سجلات المصادقة
grep "Failed password" /var/log/auth.log | tail -20
grep "Invalid user" /var/log/auth.log | awk '{print $NF}' | sort | uniq -c

# اكتشاف عناوين IP المشبوهة
cat /var/log/auth.log | grep "Failed password" | awk '{print $11}' | sort | uniq -c | sort -nr

# تحليل سجلات الويب
tail -100 /var/log/apache2/access.log | grep "404"
cat /var/log/apache2/access.log | awk '{print $1}' | sort | uniq -c | sort -nr

# مراقبة السجلات في الوقت الحقيقي
tail -f /var/log/auth.log
tail -f /var/log/syslog

# البحث عن أنماط محددة
grep -E "(union select|script>|../)" /var/log/apache2/access.log
grep -i "sql" /var/log/apache2/access.log

# إنشاء تقارير نصية
echo "تقرير تحليل السجلات - $(date)" > log_analysis_report.txt
echo "======================================" >> log_analysis_report.txt
echo "" >> log_analysis_report.txt
echo "1. محاولات تسجيل دخول فاشلة:" >> log_analysis_report.txt
grep -c "Failed password" /var/log/auth.log >> log_analysis_report.txt
echo "" >> log_analysis_report.txt
echo "2. عناوين IP الأكثر نشاطاً:" >> log_analysis_report.txt
cat /var/log/apache2/access.log | awk '{print $1}' | sort | uniq -c | sort -nr | head -10 >> log_analysis_report.txt

echo "تم تعلم تحليل السجلات بنجاح!"

4

الخطوة 4: تعلم إعداد التقارير

إعداد التقارير هو عملية إنشاء تقارير مفصلة بناءً على نتائج التحقيقات الجنائية. يجب أن تكون التقارير واضحة ومدعومة بالأدلة الرقمية.

الأهمية:

ضروري لفهم كيفية تقديم النتائج بشكل احترافي وواضح للعملاء أو السلطات القانونية

الأدوات:

Markdown، Jupyter Notebook

أمثلة إعداد التقارير:

# ===== إعداد التقارير باستخدام Markdown و Jupyter Notebook =====

# 1. تقرير Markdown نموذجي
cat > digital_forensics_report.md << 'EOF'
# تقرير الطب الشرعي الرقمي
**رقم القضية:** CASE-2024-001  
**التاريخ:** $(date +%Y-%m-%d)  
**المحقق:** محقق الطب الشرعي الرقمي  
**العميل:** قسم التحقيقات الجنائية

## الملخص التنفيذي

تم إجراء تحقيق رقمي شامل بناءً على طلب قسم التحقيقات الجنائية. 
هدف التحقيق كان تحديد وجود أدلة رقمية تتعلق بالقضية المدروسة.

### النتائج الرئيسية:
- ✅ تم جمع وتحليل 15,342 سجل نظام
- ✅ تم استعادة 47 ملفاً محذوفاً
- ⚠️ تم اكتشاف 3 أنشطة مشبوهة
- 📊 تم إنشاء 5 تقارير تحليلية

## تفاصيل التحقيق

### 1. جمع الأدلة الرقمية

#### 1.1 مصادر البيانات:
- القرص الصلب: /dev/sda1 (500GB)
- الذاكرة العشوائية: 8GB dump
- السجلات: /var/log/ (1.2GB)

#### 1.2 تقنيات الجمع:
- استخدام FTK Imager لإنشاء صورة القرص
- استخدام dd لأخذ صورة الذاكرة
- نسخ السجلات مع الحفاظ على البيانات الوصفية

### 2. تحليل الأدلة

#### 2.1 تحليل السجلات:

#### 2.2 استعادة الملفات:
| الملف | الحجم | الهاش | الحالة |
|-------|-------|-------|--------|
| secret_doc.docx | 2.1MB | a1b2... | مسترجع |
| backup.zip | 15MB | c3d4... | مسترجع |
| chat_log.txt | 350KB | e5f6... | مسترجع |

### 3. النتائج والاستنتاجات

#### 3.1 النتائج:
1. **نشاط غير مصرح به**: تم اكتشاف محاولات وصول غير مصرح بها من IP خارجي
2. **بيانات حساسة**: تم استعادة وثائق تحتوي على معلومات سرية
3. **تواريخ مهمة**: تم تحديد تواريخ أنشطة مشبوهة تتوافق مع توقيت الجريمة

#### 3.2 الاستنتاجات:
بناءً على التحليل الرقمي، يمكن الاستنتاج بأن:
- يوجد أدلة رقمية تشير إلى اختراق النظام
- تم العثور على بيانات حساسة مخزنة بشكل غير آمن
- هناك مؤشرات على محاولات إخفاء الأدلة

### 4. التوصيات

#### 4.1 توصيات فورية:
- [ ] تغيير جميع كلمات المرور
- [ ] تحديث أنظمة الحماية
- [ ] مراقبة النشاط المشبوه

#### 4.2 توصيات طويلة المدى:
- [ ] تدريب الموظفين على الأمن الرقمي
- [ ] تنفيذ نظام النسخ الاحتياطي المنتظم
- [ ] تحديث سياسات الأمان

### 5. الملحقات

#### 5.1 قائمة الأدلة:
1. `disk_image.E01` - صورة القرص الصلب
2. `memory_dump.img` - صورة الذاكرة
3. `logs_archive.tar.gz` - أرشيف السجلات

#### 5.2 الهاشات:

### 6. سلسلة الحفظ

| التاريخ | الوقت | الإجراء | المسؤول |
|---------|-------|---------|---------|
| 2024-01-15 | 09:30 | جمع الأدلة | المحقق أحمد |
| 2024-01-15 | 11:45 | تحليل أولي | المحقق محمد |
| 2024-01-16 | 14:20 | استعادة ملفات | المحقق خالد |

---
**التوقيع:**  
_________________________  
المحقق الرقمي  
التاريخ: $(date +%Y-%m-%d)
EOF

echo "تم إنشاء تقرير Markdown: digital_forensics_report.md"

# 2. برنامج Python لإعداد التقارير المتقدمة
import json
import markdown
from datetime import datetime
from tabulate import tabulate

class ForensicReportGenerator:
    def __init__(self, case_info):
        self.case_info = case_info
        self.sections = {}
        self.evidence_list = []
        self.findings = []
        self.recommendations = []
        
    def add_evidence(self, evidence_type, description, location, hash_value):
        """إضافة دليل إلى التقرير"""
        self.evidence_list.append({
            'type': evidence_type,
            'description': description,
            'location': location,
            'hash': hash_value,
            'added': datetime.now().isoformat()
        })
    
    def add_finding(self, severity, description, evidence_refs):
        """إضافة نتيجة إلى التقرير"""
        self.findings.append({
            'id': len(self.findings) + 1,
            'severity': severity,  # low, medium, high, critical
            'description': description,
            'evidence_refs': evidence_refs,
            'timestamp': datetime.now().isoformat()
        })
    
    def add_recommendation(self, priority, description, action_items):
        """إضافة توصية إلى التقرير"""
        self.recommendations.append({
            'id': len(self.recommendations) + 1,
            'priority': priority,  # low, medium, high, critical
            'description': description,
            'action_items': action_items,
            'status': 'pending'
        })
    
    def generate_markdown_report(self):
        """إنشاء تقرير Markdown"""
        md_content = f"""# تقرير الطب الشرعي الرقمي

## معلومات القضية
- **رقم القضية:** {self.case_info.get('case_number', 'N/A')}
- **التاريخ:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
- **المحقق:** {self.case_info.get('investigator', 'N/A')}
- **العميل:** {self.case_info.get('client', 'N/A')}
- **نطاق التحقيق:** {self.case_info.get('scope', 'N/A')}

## الملخص التنفيذي

{self.case_info.get('executive_summary', 'لا يوجد ملخص')}

## الأدلة الرقمية المجمعة

{self._generate_evidence_table()}

## النتائج والتحليل

{self._generate_findings_section()}

## التوصيات

{self._generate_recommendations_section()}

## سلسلة الحفظ

{self._generate_chain_of_custody()}

## الملحقات

{self._generate_attachments_section()}

---
**تم إعداد هذا التقرير بواسطة:** {self.case_info.get('investigator', 'محقق رقمي')}  
**التاريخ النهائي:** {datetime.now().strftime('%Y-%m-%d')}  
**الإصدار:** 1.0
"""
        
        return md_content
    
    def _generate_evidence_table(self):
        """إنشاء جدول الأدلة"""
        if not self.evidence_list:
            return "لم يتم جمع أي أدلة."
        
        table_data = []
        for i, evidence in enumerate(self.evidence_list, 1):
            table_data.append([
                i,
                evidence['type'],
                evidence['description'],
                evidence['location'],
                evidence['hash'][:16] + '...' if len(evidence['hash']) > 16 else evidence['hash']
            ])
        
        headers = ['#', 'النوع', 'الوصف', 'الموقع', 'الهاش']
        return tabulate(table_data, headers=headers, tablefmt='github')
    
    def _generate_findings_section(self):
        """إنشاء قسم النتائج"""
        if not self.findings:
            return "لم يتم العثور على نتائج."
        
        findings_md = ""
        for finding in self.findings:
            severity_icon = {
                'low': '🟢',
                'medium': '🟡',
                'high': '🟠',
                'critical': '🔴'
            }.get(finding['severity'], '⚪')
            
            findings_md += f"\n### {severity_icon} النتيجة #{finding['id']}: {finding['severity'].upper()}\n"
            findings_md += f"{finding['description']}\n"
            
            if finding['evidence_refs']:
                findings_md += "\n**الأدلة المرجعية:**\n"
                for ref in finding['evidence_refs']:
                    findings_md += f"- {ref}\n"
        
        return findings_md
    
    def _generate_recommendations_section(self):
        """إنشاء قسم التوصيات"""
        if not self.recommendations:
            return "لا توجد توصيات."
        
        recommendations_md = ""
        for rec in self.recommendations:
            priority_icon = {
                'low': '📝',
                'medium': '⚠️',
                'high': '🚨',
                'critical': '🔥'
            }.get(rec['priority'], '📌')
            
            recommendations_md += f"\n### {priority_icon} التوصية #{rec['id']}\n"
            recommendations_md += f"**الأولوية:** {rec['priority'].upper()}\n\n"
            recommendations_md += f"{rec['description']}\n"
            
            if rec['action_items']:
                recommendations_md += "\n**بنود العمل:**\n"
                for item in rec['action_items']:
                    recommendations_md += f"- [ ] {item}\n"
        
        return recommendations_md
    
    def _generate_chain_of_custody(self):
        """إنشاء سلسلة الحفظ"""
        chain = [
            {'date': '2024-01-15', 'time': '09:30', 'action': 'جمع الأدلة الأولية', 'responsible': 'المحقق أحمد'},
            {'date': '2024-01-15', 'time': '14:00', 'action': 'تحليل الصور', 'responsible': 'المحقق محمد'},
            {'date': '2024-01-16', 'time': '10:15', 'action': 'استعادة الملفات', 'responsible': 'المحقق خالد'},
            {'date': datetime.now().strftime('%Y-%m-%d'), 'time': datetime.now().strftime('%H:%M'), 
             'action': 'إعداد التقرير النهائي', 'responsible': self.case_info.get('investigator', 'المحقق')}
        ]
        
        table_data = []
        for i, entry in enumerate(chain, 1):
            table_data.append([
                i,
                entry['date'],
                entry['time'],
                entry['action'],
                entry['responsible']
            ])
        
        headers = ['#', 'التاريخ', 'الوقت', 'الإجراء', 'المسؤول']
        return tabulate(table_data, headers=headers, tablefmt='github')
    
    def _generate_attachments_section(self):
        """إنشاء قسم الملحقات"""
        attachments = [
            'تقرير_تحليل_السجلات.pdf',
            'قائمة_الهاشات.txt',
            'صور_الأقراص/',
            'الملفات_المسترجعية/',
            'السجلات_الخام/'
        ]
        
        attachments_md = "### الملفات المرفقة:\n\n"
        for attachment in attachments:
            attachments_md += f"- `{attachment}`\n"
        
        return attachments_md
    
    def save_report(self, filename="forensic_report"):
        """حفظ التقرير بجميع الصيغ"""
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        
        # حفظ كـ Markdown
        md_content = self.generate_markdown_report()
        md_filename = f"{filename}_{timestamp}.md"
        with open(md_filename, 'w', encoding='utf-8') as f:
            f.write(md_content)
        
        # حفظ كـ HTML
        html_content = markdown.markdown(md_content, extensions=['tables'])
        html_filename = f"{filename}_{timestamp}.html"
        with open(html_filename, 'w', encoding='utf-8') as f:
            f.write(f"""


    
    
    تقرير الطب الشرعي الرقمي
    


{html_content}

""")
        
        # حفظ كـ JSON (للمعالجة الآلية)
        json_report = {
            'metadata': {
                'case_number': self.case_info.get('case_number'),
                'investigator': self.case_info.get('investigator'),
                'generation_date': datetime.now().isoformat(),
                'report_version': '1.0'
            },
            'evidence': self.evidence_list,
            'findings': self.findings,
            'recommendations': self.recommendations
        }
        
        json_filename = f"{filename}_{timestamp}.json"
        with open(json_filename, 'w', encoding='utf-8') as f:
            json.dump(json_report, f, indent=2, ensure_ascii=False)
        
        print(f"✅ تم إنشاء التقارير:")
        print(f"   📄 Markdown: {md_filename}")
        print(f"   🌐 HTML: {html_filename}")
        print(f"   📊 JSON: {json_filename}")
        
        return {
            'md': md_filename,
            'html': html_filename,
            'json': json_filename
        }

# تشغيل منشئ التقارير
if __name__ == "__main__":
    print("بدء إنشاء تقرير الطب الشرعي الرقمي")
    print("=" * 50)
    
    # معلومات القضية
    case_info = {
        'case_number': 'CASE-2024-DF-001',
        'investigator': 'د. أحمد محمد - محقق الطب الشرعي الرقمي',
        'client': 'قسم التحقيقات الجنائية',
        'scope': 'تحقيق رقمي في نظام الخادم الرئيسي',
        'executive_summary': '''تم إجراء تحقيق رقمي شامل في النظام المستهدف بعد بلاغ عن نشاط غير مصرح به.
        كشف التحليل عن أدلة على محاولات اختراق متعددة واسترجاع ملفات محذوفة تحتوي على معلومات حساسة.'''
    }
    
    # إنشاء التقرير
    report_generator = ForensicReportGenerator(case_info)
    
    # إضافة الأدلة
    print("\n1. إضافة الأدلة الرقمية...")
    report_generator.add_evidence(
        evidence_type='صورة قرص',
        description='صورة كاملة للقرص الصلب /dev/sda1',
        location='/evidence/disk_image.E01',
        hash='a1b2c3d4e5f678901234567890123456789012345678901234567890123456'
    )
    
    report_generator.add_evidence(
        evidence_type='سجلات نظام',
        description='سجلات المصادقة والوصول',
        location='/evidence/system_logs.tar.gz',
        hash='b2c3d4e5f6a789012345678901234567890123456789012345678901234567'
    )
    
    report_generator.add_evidence(
        evidence_type='ملفات مسترجعة',
        description='47 ملف محذوف تم استرجاعه',
        location='/evidence/recovered_files/',
        hash='c3d4e5f6a7b890123456789012345678901234567890123456789012345678'
    )
    
    # إضافة النتائج
    print("2. إضافة النتائج...")
    report_generator.add_finding(
        severity='critical',
        description='تم اكتشاف 127 محاولة تسجيل دخول فاشلة من عنوان IP خارجي (203.0.113.45)',
        evidence_refs=['سجلات المصادقة', 'تقرير تحليل السجلات']
    )
    
    report_generator.add_finding(
        severity='high',
        description='تم استعادة ملفات محذوفة تحتوي على معلومات مالية حساسة',
        evidence_refs=['الملفات المسترجعة', 'تحليل المحتوى']
    )
    
    report_generator.add_finding(
        severity='medium',
        description='وجود ثغرات أمنية غير مصححة في النظام',
        evidence_refs=['تقرير الفحص الأمني']
    )
    
    # إضافة التوصيات
    print("3. إضافة التوصيات...")
    report_generator.add_recommendation(
        priority='critical',
        description='تأمين النظام ضد الهجمات الخارجية',
        action_items=[
            'تحديث جميع أنظمة التشغيل والبرمجيات',
            'تنفيذ جدار حماية أكثر صرامة',
            'حظر عناوين IP المشبوهة'
        ]
    )
    
    report_generator.add_recommendation(
        priority='high',
        description='تعزيز إجراءات المصادقة',
        action_items=[
            'تفعيل المصادقة متعددة العوامل',
            'تنفيذ سياسة كلمات مرور قوية',
            'مراقبة نشاط المستخدمين'
        ]
    )
    
    # حفظ التقرير
    print("4. حفظ التقارير...")
    reports = report_generator.save_report("digital_forensics_case_001")
    
    print("\n" + "=" * 50)
    print("✅ تم إنشاء تقرير الطب الشرعي الرقمي بنجاح")
    print(f"   • الأدلة المجمعة: {len(report_generator.evidence_list)}")
    print(f"   • النتائج المبلغ عنها: {len(report_generator.findings)}")
    print(f"   • التوصيات: {len(report_generator.recommendations)}")
    print(f"   • ملفات التقرير: {len(reports)} صيغ مختلفة")

# 3. Jupyter Notebook للتحليل التفاعلي
cat > digital_forensics_analysis.ipynb << 'EOF'
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# تحليل الطب الشرعي الرقمي - دفتر Jupyter\n",
    "\n",
    "**رقم القضية:** CASE-2024-001  \n",
    "**التاريخ:** $(date +%Y-%m-%d)  \n",
    "**المحقق:** محقق رقمي"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. استيراد المكتبات"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import json\n",
    "from datetime import datetime\n",
    "import hashlib\n",
    "import re\n",
    "\n",
    "# إعداد العرض\n",
    "plt.style.use('seaborn-darkgrid')\n",
    "plt.rcParams['figure.figsize'] = (12, 6)\n",
    "plt.rcParams['font.family'] = 'DejaVu Sans'\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. تحليل سجلات النظام"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# قراءة وتحليل سجلات النظام\n",
    "def analyze_auth_logs(log_file):\n",
    "    \"\"\"تحليل سجلات المصادقة\"\"\"\n",
    "    patterns = {\n",
    "        'failed_login': r'Failed password for (\\S+) from (\\S+)',\n",
    "        'invalid_user': r'Invalid user (\\S+) from (\\S+)',\n",
    "        'accepted_login': r'Accepted password for (\\S+) from (\\S+)'\n",
    "    }\n",
    "    \n",
    "    results = {\n",
    "        'failed_logins': [],\n",
    "        'invalid_users': [],\n",
    "        'successful_logins': []\n",
    "    }\n",
    "    \n",
    "    with open(log_file, 'r', encoding='utf-8', errors='ignore') as f:\n",
    "        for line in f:\n",
    "            for pattern_type, pattern in patterns.items():\n",
    "                match = re.search(pattern, line)\n",
    "                if match:\n",
    "                    results[pattern_type + 's'].append({\n",
    "                        'user': match.group(1),\n",
    "                        'ip': match.group(2),\n",
    "                        'line': line.strip()[:100]\n",
    "                    })\n",
    "    \n",
    "    return results\n",
    "\n",
    "# تشغيل التحليل\n",
    "print(\"بدء تحليل سجلات المصادقة...\")\n",
    "auth_results = analyze_auth_logs('/var/log/auth.log')\n",
    "\n",
    "print(f\"محاولات تسجيل دخول فاشلة: {len(auth_results['failed_logins'])}\")\n",
    "print(f\"مستخدمين غير صالحين: {len(auth_results['invalid_users'])}\")\n",
    "print(f\"تسجيلات دخول ناجحة: {len(auth_results['successful_logins'])}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. تصور البيانات"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# إنشاء تصورات للبيانات\n",
    "def create_visualizations(results):\n",
    "    \"\"\"إنشاء رسوم بيانية للنتائج\"\"\"\n",
    "    \n",
    "    # 1. مخطط الأعمدة للنشاط\n",
    "    activity_counts = {\n",
    "        'محاولات فاشلة': len(results['failed_logins']),\n",
    "        'مستخدمين غير صالحين': len(results['invalid_users']),\n",
    "        'تسجيلات ناجحة': len(results['successful_logins'])\n",
    "    }\n",
    "    \n",
    "    plt.figure(figsize=(10, 6))\n",
    "    bars = plt.bar(activity_counts.keys(), activity_counts.values(), \n",
    "                   color=['#e74c3c', '#f39c12', '#27ae60'])\n",
    "    plt.title('نشاط تسجيل الدخول في النظام', fontsize=14, fontweight='bold')\n",
    "    plt.ylabel('عدد الأحداث', fontsize=12)\n",
    "    plt.xticks(rotation=45)\n",
    "    \n",
       " # إضافة القيم على الأعمدة\n",
    "    for bar in bars:\n",
    "        height = bar.get_height()\n",
    "        plt.text(bar.get_x() + bar.get_width()/2., height,\n",
    "                 f'{int(height)}', ha='center', va='bottom')\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "    # 2. تحليل عناوين IP\n",
    "    if results['failed_logins']:\n",
    "        ip_counts = {}\n",
    "        for entry in results['failed_logins']:\n",
    "            ip = entry['ip']\n",
    "            ip_counts[ip] = ip_counts.get(ip, 0) + 1\n",
    "        \n",
    "        # عرض أهم 10 عناوين IP\n",
    "        top_ips = sorted(ip_counts.items(), key=lambda x: x[1], reverse=True)[:10]\n",
    "        \n",
    "        plt.figure(figsize=(12, 6))\n",
    "        ips, counts = zip(*top_ips) if top_ips else ([], [])\n",
    "        bars = plt.barh(ips, counts, color='#3498db')\n",
    "        plt.title('أهم 10 عناوين IP في محاولات تسجيل الدخول الفاشلة', \n",
    "                  fontsize=14, fontweight='bold')\n",
    "        plt.xlabel('عدد المحاولات', fontsize=12)\n",
    "        \n",
    "        # إضافة القيم\n",
    "        for bar in bars:\n",
    "            width = bar.get_width()\n",
    "            plt.text(width + 0.5, bar.get_y() + bar.get_height()/2.,\n",
    "                     f'{int(width)}', ha='left', va='center')\n",
    "        \n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "# تشغيل التصورات\n",
    "print(\"إنشاء التصورات البيانية...\")\n",
    "create_visualizations(auth_results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. تحليل الملفات المسترجعة"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# تحليل الملفات المسترجعة\n",
    "def analyze_recovered_files(file_list):\n",
    "    \"\"\"تحليل الملفات المسترجعة\"\"\"\n",
    "    analysis = {\n",
    "        'file_types': {},\n",
    "        'sizes': [],\n",
    "        'suspicious_files': []\n",
    "    }\n",
    "    \n",
    "    suspicious_keywords = ['password', 'secret', 'confidential', \n",
    "                           'admin', 'bank', 'credit', 'token']\n",
    "    \n",
    "    for file_info in file_list:\n",
    "        # تحليل نوع الملف\n",
    "        file_ext = file_info.get('extension', 'unknown')\n",
    "        analysis['file_types'][file_ext] = analysis['file_types'].get(file_ext, 0) + 1\n",
    "        \n",
    "        # تحليل الحجم\n",
    "        file_size = file_info.get('size', 0)\n",
    "        analysis['sizes'].append(file_size)\n",
    "        \n",
    "        # البحث عن كلمات مشبوهة\n",
    "        content = file_info.get('content', '')\n",
    "        if any(keyword in content.lower() for keyword in suspicious_keywords):\n",
    "            analysis['suspicious_files'].append({\n",
    "                'filename': file_info.get('filename'),\n",
    "                'size': file_size,\n",
    "                'matches': [k for k in suspicious_keywords if k in content.lower()]\n",
    "            })\n",
    "    \n",
    "    return analysis\n",
    "\n",
    "# بيانات نموذجية\n",
    "recovered_files = [\n",
    "    {'filename': 'config_backup.txt', 'extension': 'txt', 'size': 2048, \n",
    "     'content': 'Database password: admin123'},\n",
    "    {'filename': 'financial_report.pdf', 'extension': 'pdf', 'size': 1024000},\n",
    "    {'filename': 'chat_logs.db', 'extension': 'db', 'size': 512000},\n",
    "    {'filename': 'secret_notes.docx', 'extension': 'docx', 'size': 256000,\n",
    "     'content': 'Confidential meeting notes'}\n",
    "]\n",
    "\n",
    "print(\"تحليل الملفات المسترجعة...\")\n",
    "file_analysis = analyze_recovered_files(recovered_files)\n",
    "\n",
    "print(f\"أنواع الملفات: {file_analysis['file_types']}\")\n",
    "print(f\"إجمالي الحجم: {sum(file_analysis['sizes']):,} بايت\")\n",
    "print(f\"ملفات مشبوهة: {len(file_analysis['suspicious_files'])}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. النتائج والتوصيات"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# عرض النتائج النهائية\n",
    "print(\"# النتائج النهائية\\n\")\n",
    "\n",
    "print(\"## الملخص:\\n\")\n",
    "print(f\"1. تم تحليل {len(auth_results['failed_logins'])} محاولة تسجيل دخول فاشلة\")\n",
    "print(f\"2. تم العثور على {len(auth_results['invalid_users'])} مستخدم غير صالح\")\n",
    "print(f\"3. تم تحليل {len(recovered_files)} ملف مسترجع\")\n",
    "print(f\"4. تم تحديد {len(file_analysis['suspicious_files'])} ملف مشبوه\\n\")\n",
    "\n",
    "print(\"## التوصيات:\\n\")\n",
    "recommendations = [\n",
    "    \"تفعيل المصادقة متعددة العوامل للمستخدمين المميزين\",\n",
    "    \"مراجعة سياسة كلمات المرور وتطبيق معايير أمان أقوى\",\n",
    "    \"مراقبة نشاط عناوين IP المشبوهة\",\n",
    "    \"إجراء تدقيق أمني دوري للأنظمة\",\n",
    "    \"تثقيف المستخدمين حول الأمن الرقمي\"\n",
    "]\n",
    "\n",
    "for i, rec in enumerate(recommendations, 1):\n",
    "    print(f\"{i}. {rec}\")\n",
    "\n",
    "print(\"\\n---\\n**تم إنشاء هذا التحليل في:**\", datetime.now().strftime('%Y-%m-%d %H:%M:%S'))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
EOF

echo "تم إنشاء دفتر Jupyter Notebook: digital_forensics_analysis.ipynb"

echo "تم تعلم إعداد التقارير بنجاح!"

هندسة الطب الشرعي الرقمي

جمع الأدلة

FTK Imager، Autopsy، تصوير الأقراص

استعادة البيانات

TestDisk، PhotoRec، استرجاع الملفات

تحليل السجلات

Splunk، ELK Stack، تحليل الأنماط

التقرير النهائي

Markdown، Jupyter، تقديم الأدلة

أدوات الطب الشرعي الرقمي

FTK Imager

أداة تصوير الأقراص وجمع الأدلة الرقمية

تصوير جمع تحليل

Autopsy

منصة شاملة للتحقيقات الجنائية الرقمية

فحص تحقيق تقارير

TestDisk

استعادة الملفات المحذوفة وأنظمة الملفات

استعادة إصلاح استرجاع

PhotoRec

استعادة الصور والملفات من أنظمة تالفة

صور وسائط بيانات

Splunk

تحليل سجلات النظام والكشف عن التهديدات

تحليل رصد كشف

ELK Stack

Elasticsearch، Logstash، Kibana للتحليل

بحث تصور مراقبة

المزايا والتحديات

المزايا

طلب عالي: هناك طلب كبير على محققي الطب الشرعي الرقمي، خاصة في الشركات التي تعتمد على الأمن السيبراني والتحقيقات القانونية
أدوات مجانية: معظم الأدوات المستخدمة مثل TestDisk و Autopsy مجانية ومفتوحة المصدر
تأثير إيجابي: يمكنك المساهمة في حل القضايا الجنائية والمساعدة في تحقيق العدالة
إبداع لا محدود: يمكنك تصميم استراتيجيات جديدة لجمع الأدلة الرقمية وتحليلها
مجال متخصص: مجال مطلوب في المحاكم والتحقيقات الجنائية

التحديات

منحنى التعلم الحاد: يتطلب فهماً جيداً لأنظمة التشغيل والشبكات وأساسيات التحقيقات الجنائية
مسؤولية كبيرة: يجب أن تكون حذراً جداً عند التعامل مع الأدلة الرقمية لتجنب التسبب في أضرار قانونية
تحديثات متكررة: الأدوات والتقنيات تتطور باستمرار مما يتطلب تحديث المعرفة بشكل منتظم
ضغوط قانونية: العمل تحت ضغط مواعيد المحاكم والتحقيقات

مجالات عمل محقق الطب الشرعي الرقمي

تحقيق حواسيب

فحص الحواسيب الشخصية والمحمولة

Windows macOS Linux

تحقيق هواتف

فحص الهواتف الذكية والأجهزة اللوحية

iOS Android سجلات

تحقيق شبكات

فحص حركة مرور الشبكات والخوادم

سجلات حزم اتصالات

تحقيق سحابة

فحص البيانات والتطبيقات السحابية

AWS Azure Google

تحقيق قواعد بيانات

فحص وتحليل قواعد البيانات والبيانات

SQL NoSQL تحليل

شهادة محكمة

تقديم الأدلة والشهادة في المحاكم

شهادة أدلة قانون

الخلاصة

محقق الطب الشرعي الرقمي يلعب دوراً حاسماً في جمع الأدلة الرقمية وتحليلها لحل القضايا الجنائية. من خلال إتقان FTK Imager، Autopsy، TestDisk، Splunk، وتحليل السجلات، يمكنك بناء مهارات قوية في التحقيقات الرقمية والمساعدة في تحقيق العدالة.

نصائح للبدء:

ابدأ بتعلم أساسيات أنظمة التشغيل والشبكات
تدرب على استخدام FTK Imager و Autopsy في بيئة آمنة
تعلم استعادة الملفات باستخدام TestDisk و PhotoRec
أتقن تحليل السجلات باستخدام Splunk و ELK Stack
تعلم إعداد التقارير باستخدام Markdown و Jupyter Notebook
احصل على شهادات متخصصة مثل CHFI أو GCFA

موارد تعليمية:

FTK Imager Autopsy TestDisk Splunk