192.168.1.100 - - [15/Jan/2024:10:30:45 +0900] "GET /admin/login.php HTTP/1.1" 200 1234 "-" "Mozilla/5.0"
10.0.0.50 - admin [15/Jan/2024:10:31:12 +0900] "POST /api/users HTTP/1.1" 403 567 "-" "curl/7.68.0"
172.16.0.25 - - [15/Jan/2024:10:31:45 +0900] "GET /../../../etc/passwd HTTP/1.1" 404 162 "-" "Nikto"

Jan 15 10:25:30 webserver sshd[12345]: Failed password for root from 203.0.113.50 port 45678 ssh2
Jan 15 10:25:35 webserver sshd[12346]: Failed password for root from 203.0.113.50 port 45679 ssh2
Jan 15 10:25:40 webserver sshd[12347]: Failed password for admin from 203.0.113.50 port 45680 ssh2

{
  "timestamp": "2024-01-15T10:30:45Z",
  "level": "ERROR",
  "user_id": "user123",
  "action": "database_query",
  "query": "SELECT * FROM users WHERE id=1 OR 1=1--",
  "ip_address": "192.168.1.100"
}

import re
from datetime import datetime
from collections import defaultdict

class LogParser:
    def __init__(self):
        # Apache/Nginx Combined Log Format 정규표현식
        self.log_pattern = re.compile(
            r'(?P<ip>[\d.]+) - (?P<user>[\w-]+) '
            r'\[(?P<timestamp>[^\]]+)\] '
            r'"(?P<method>\w+) (?P<path>[^\s]+) (?P<protocol>[^"]+)" '
            r'(?P<status>\d+) (?P<size>\d+) '
            r'"(?P<referer>[^"]*)" "(?P<user_agent>[^"]*)"'
        )
        
    def parse_line(self, line):
        """한 줄의 로그를 파싱하여 딕셔너리로 반환"""
        match = self.log_pattern.match(line)
        if match:
            return match.groupdict()
        return None
    
    def parse_file(self, filepath):
        """로그 파일 전체를 파싱"""
        parsed_logs = []
        
        try:
            with open(filepath, 'r', encoding='utf-8') as f:
                for line_num, line in enumerate(f, 1):
                    parsed = self.parse_line(line.strip())
                    if parsed:
                        parsed['line_number'] = line_num
                        parsed_logs.append(parsed)
                    else:
                        print(f"⚠️ 파싱 실패 (라인 {line_num}): {line[:50]}...")
        
        except FileNotFoundError:
            print(f"❌ 파일을 찾을 수 없습니다: {filepath}")
        except Exception as e:
            print(f"❌ 오류 발생: {str(e)}")
        
        return parsed_logs

# 사용 예제
parser = LogParser()
logs = parser.parse_file('/var/log/apache2/access.log')

print(f"✅ 총 {len(logs)}개의 로그 엔트리를 파싱했습니다!")
if logs:
    print(f"첫 번째 로그: {logs[0]}")

import time
import os

class RealTimeLogMonitor:
    def __init__(self, filepath, callback):
        self.filepath = filepath
        self.callback = callback
        self.parser = LogParser()
        
    def follow(self):
        """tail -f 처럼 실시간으로 로그 추적"""
        print(f"🔍 {self.filepath} 모니터링 시작...")
        
        # 파일의 끝으로 이동
        with open(self.filepath, 'r') as f:
            f.seek(0, os.SEEK_END)
            
            while True:
                line = f.readline()
                
                if not line:
                    time.sleep(0.1)  # 새 로그 대기
                    continue
                
                # 로그 파싱 및 콜백 실행
                parsed = self.parser.parse_line(line.strip())
                if parsed:
                    self.callback(parsed)

def security_event_handler(log_entry):
    """보안 이벤트 처리 콜백 함수"""
    ip = log_entry['ip']
    path = log_entry['path']
    status = int(log_entry['status'])
    
    # 의심스러운 패턴 탐지
    suspicious_patterns = [
        r'\.\./\.\./',  # Path Traversal
        r'union.*select',  # SQL Injection
        r'<script>',  # XSS
        r'/etc/passwd',  # 시스템 파일 접근
        r'cmd\.exe',  # 명령어 실행
    ]
    
    for pattern in suspicious_patterns:
        if re.search(pattern, path, re.IGNORECASE):
            print(f"🚨 보안 위협 탐지!")
            print(f"   IP: {ip}")
            print(f"   경로: {path}")
            print(f"   패턴: {pattern}")
            print(f"   상태 코드: {status}")
            print("-" * 50)
            
            # 여기서 알림 전송, DB 저장 등의 작업 수행
            send_alert(log_entry)

def send_alert(log_entry):
    """알림 전송 (이메일, Slack 등)"""
    # 실제 구현에서는 이메일이나 Slack 웹훅 등을 사용
    print(f"📧 관리자에게 알림 전송: {log_entry['ip']} 의심 활동 탐지")

# 실시간 모니터링 시작
monitor = RealTimeLogMonitor('/var/log/apache2/access.log', security_event_handler)
# monitor.follow()  # 실제 실행 시 주석 해제

from collections import defaultdict
from datetime import datetime, timedelta

class FrequencyDetector:
    def __init__(self, time_window=60, threshold=100):
        """
        time_window: 시간 윈도우 (초)
        threshold: 임계값 (해당 시간 내 최대 요청 수)
        """
        self.time_window = time_window
        self.threshold = threshold
        self.request_history = defaultdict(list)
        
    def check_request(self, ip, timestamp):
        """요청 빈도 체크"""
        current_time = datetime.strptime(timestamp, '%d/%b/%Y:%H:%M:%S %z')
        
        # 해당 IP의 요청 기록 가져오기
        requests = self.request_history[ip]
        
        # 시간 윈도우 밖의 오래된 요청 제거
        cutoff_time = current_time - timedelta(seconds=self.time_window)
        requests = [t for t in requests if t > cutoff_time]
        
        # 현재 요청 추가
        requests.append(current_time)
        self.request_history[ip] = requests
        
        # 임계값 초과 체크
        if len(requests) > self.threshold:
            return True, len(requests)
        
        return False, len(requests)
    
    def get_top_requesters(self, top_n=10):
        """가장 많이 요청한 IP 목록"""
        ip_counts = {ip: len(times) for ip, times in self.request_history.items()}
        sorted_ips = sorted(ip_counts.items(), key=lambda x: x[1], reverse=True)
        return sorted_ips[:top_n]

# 사용 예제
detector = FrequencyDetector(time_window=60, threshold=100)

# 로그 분석 중...
for log in logs:
    is_suspicious, count = detector.check_request(
        log['ip'], 
        log['timestamp']
    )
    
    if is_suspicious:
        print(f"⚠️ 의심스러운 활동 탐지!")
        print(f"   IP: {log['ip']}")
        print(f"   60초 내 요청 수: {count}")
        print(f"   임계값: {detector.threshold}")
        print("-" * 50)

# 상위 요청자 출력
print("\n📊 상위 10개 요청 IP:")
for ip, count in detector.get_top_requesters():
    print(f"   {ip}: {count}회")

import numpy as np
from datetime import datetime

class AnomalyDetector:
    def __init__(self):
        self.user_profiles = defaultdict(lambda: {
            'access_hours': [],
            'request_sizes': [],
            'accessed_paths': set()
        })
        
    def learn_profile(self, logs):
        """사용자 프로필 학습"""
        for log in logs:
            user = log.get('user', 'anonymous')
            timestamp = datetime.strptime(log['timestamp'], '%d/%b/%Y:%H:%M:%S %z')
            hour = timestamp.hour
            size = int(log['size'])
            path = log['path']
            
            profile = self.user_profiles[user]
            profile['access_hours'].append(hour)
            profile['request_sizes'].append(size)
            profile['accessed_paths'].add(path)
        
        # 통계 계산
        for user, profile in self.user_profiles.items():
            hours = np.array(profile['access_hours'])
            sizes = np.array(profile['request_sizes'])
            
            profile['hour_mean'] = np.mean(hours)
            profile['hour_std'] = np.std(hours)
            profile['size_mean'] = np.mean(sizes)
            profile['size_std'] = np.std(sizes)
    
    def detect_anomaly(self, log, z_threshold=3):
        """이상 징후 탐지 (Z-score 기반)"""
        user = log.get('user', 'anonymous')
        
        if user not in self.user_profiles:
            return False, "신규 사용자"
        
        profile = self.user_profiles[user]
        timestamp = datetime.strptime(log['timestamp'], '%d/%b/%Y:%H:%M:%S %z')
        hour = timestamp.hour
        size = int(log['size'])
        path = log['path']
        
        anomalies = []
        
        # 접속 시간 이상 탐지
        if profile['hour_std'] > 0:
            hour_z = abs(hour - profile['hour_mean']) / profile['hour_std']
            if hour_z > z_threshold:
                anomalies.append(f"비정상적인 접속 시간 (Z-score: {hour_z:.2f})")
        
        # 요청 크기 이상 탐지
        if profile['size_std'] > 0:
            size_z = abs(size - profile['size_mean']) / profile['size_std']
            if size_z > z_threshold:
                anomalies.append(f"비정상적인 요청 크기 (Z-score: {size_z:.2f})")
        
        # 새로운 경로 접근 탐지
        if path not in profile['accessed_paths']:
            anomalies.append(f"처음 접근하는 경로: {path}")
        
        return len(anomalies) > 0, anomalies

# 사용 예제
anomaly_detector = AnomalyDetector()

# 학습 단계 (과거 로그로 정상 패턴 학습)
print("📚 정상 패턴 학습 중...")
training_logs = parser.parse_file('/var/log/apache2/access.log.1')  # 과거 로그
anomaly_detector.learn_profile(training_logs)

# 탐지 단계 (새로운 로그 분석)
print("\n🔍 이상 징후 탐지 중...")
for log in logs:
    is_anomaly, details = anomaly_detector.detect_anomaly(log)
    
    if is_anomaly:
        print(f"🚨 이상 징후 발견!")
        print(f"   사용자: {log.get('user', 'anonymous')}")
        print(f"   IP: {log['ip']}")
        print(f"   시간: {log['timestamp']}")
        print(f"   상세:")
        for detail in details:
            print(f"      - {detail}")
        print("-" * 50)

class MultiSourceCorrelator:
    def __init__(self):
        self.events = []
        self.attack_chains = []
        
    def add_event(self, source, event_type, ip, timestamp, details):
        """이벤트 추가"""
        event = {
            'source': source,
            'type': event_type,
            'ip': ip,
            'timestamp': timestamp,
            'details': details
        }
        self.events.append(event)
        
    def correlate_events(self, time_window=300):
        """이벤트 상관 분석 (5분 윈도우)"""
        # IP별로 이벤트 그룹화
        ip_events = defaultdict(list)
        for event in self.events:
            ip_events[event['ip']].append(event)
        
        # 공격 체인 탐지
        for ip, events in ip_events.items():
            # 시간순 정렬
            events.sort(key=lambda x: x['timestamp'])
            
            # 의심스러운 패턴 찾기
            attack_patterns = self._detect_attack_patterns(events, time_window)
            
            if attack_patterns:
                self.attack_chains.append({
                    'ip': ip,
                    'patterns': attack_patterns,
                    'events': events
                })
        
        return self.attack_chains
    
    def _detect_attack_patterns(self, events, time_window):
        """공격 패턴 탐지"""
        patterns = []
        
        # 패턴 1: 포트 스캔 → 웹 공격
        port_scan = any(e['type'] == 'port_scan' for e in events)
        web_attack = any(e['type'] == 'web_attack' for e in events)
        
        if port_scan and web_attack:
            patterns.append('reconnaissance_to_exploitation')
        
        # 패턴 2: 로그인 실패 → 성공 → 권한 상승
        login_failures = [e for e in events if e['type'] == 'login_failure']
        login_success = [e for e in events if e['type'] == 'login_success']
        privilege_escalation = [e for e in events if e['type'] == 'privilege_escalation']
        
        if len(login_failures) > 5 and login_success and privilege_escalation:
            patterns.append('brute_force_to_privilege_escalation')
        
        # 패턴 3: SQL Injection → 데이터 접근
        sql_injection = any(e['type'] == 'sql_injection' for e in events)
        data_access = any(e['type'] == 'sensitive_data_access' for e in events)
        
        if sql_injection and data_access:
            patterns.append('sql_injection_to_data_breach')
        
        return patterns

# 사용 예제
correlator = MultiSourceCorrelator()

# 방화벽 로그에서 포트 스캔 탐지
correlator.add_event(
    source='firewall',
    event_type='port_scan',
    ip='203.0.113.50',
    timestamp=datetime.now(),
    details={'scanned_ports': [22, 80, 443, 3306]}
)

# 웹 서버 로그에서 SQL Injection 시도 탐지
correlator.add_event(
    source='web_server',
    event_type='sql_injection',
    ip='203.0.113.50',
    timestamp=datetime.now(),
    details={'query': "' OR '1'='1"}
)

# 데이터베이스 로그에서 민감한 데이터 접근 탐지
correlator.add_event(
    source='database',
    event_type='sensitive_data_access',
    ip='203.0.113.50',
    timestamp=datetime.now(),
    details={'table': 'users', 'columns': ['password', 'credit_card']}
)

# 상관 분석 실행
attack_chains = correlator.correlate_events()

for chain in attack_chains:
    print(f"🚨 공격 체인 탐지!")
    print(f"   공격자 IP: {chain['ip']}")
    print(f"   탐지된 패턴: {', '.join(chain['patterns'])}")
    print(f"   관련 이벤트 수: {len(chain['events'])}")
    print("-" * 50)

from sklearn.ensemble import IsolationForest
from sklearn.preprocessing import StandardScaler
import pandas as pd

class MLBasedDetector:
    def __init__(self):
        self.model = IsolationForest(contamination=0.1, random_state=42)
        self.scaler = StandardScaler()
        self.is_trained = False
        
    def extract_features(self, logs):
        """로그에서 특징 추출"""
        features = []
        
        for log in logs:
            timestamp = datetime.strptime(log['timestamp'], '%d/%b/%Y:%H:%M:%S %z')
            
            feature = {
                'hour': timestamp.hour,
                'day_of_week': timestamp.weekday(),
                'status_code': int(log['status']),
                'response_size': int(log['size']),
                'path_length': len(log['path']),
                'has_query_string': '?' in log['path'],
                'method_post': log['method'] == 'POST',
                'method_get': log['method'] == 'GET',
            }
            
            features.append(feature)
        
        return pd.DataFrame(features)
    
    def train(self, normal_logs):
        """정상 로그로 모델 학습"""
        print("🤖 머신러닝 모델 학습 중...")
        
        features = self.extract_features(normal_logs)
        features_scaled = self.scaler.fit_transform(features)
        
        self.model.fit(features_scaled)
        self.is_trained = True
        
        print("✅ 학습 완료!")
    
    def predict(self, logs):
        """이상 로그 예측"""
        if not self.is_trained:
            raise Exception("모델이 학습되지 않았습니다!")
        
        features = self.extract_features(logs)
        features_scaled = self.scaler.transform(features)
        
        # -1: 이상, 1: 정상
        predictions = self.model.predict(features_scaled)
        scores = self.model.score_samples(features_scaled)
        
        results = []
        for i, (log, pred, score) in enumerate(zip(logs, predictions, scores)):
            if pred == -1:
                results.append({
                    'log': log,
                    'anomaly_score': score,
                    'is_anomaly': True
                })
        
        return results

# 사용 예제
ml_detector = MLBasedDetector()

# 정상 로그로 학습
normal_logs = parser.parse_file('/var/log/apache2/access.log.old')
ml_detector.train(normal_logs)

# 새로운 로그 분석
new_logs = parser.parse_file('/var/log/apache2/access.log')
anomalies = ml_detector.predict(new_logs)

print(f"\n🔍 {len(anomalies)}개의 이상 로그 탐지!")
for anomaly in anomalies[:5]:  # 상위 5개만 출력
    log = anomaly['log']
    score = anomaly['anomaly_score']
    
    print(f"\n⚠️ 이상 로그 발견 (점수: {score:.3f})")
    print(f"   IP: {log['ip']}")
    print(f"   경로: {log['path']}")
    print(f"   상태: {log['status']}")
    print(f"   크기: {log['size']}")

import json
import sqlite3
from datetime import datetime
import threading
import queue

class SecurityMonitoringSystem:
    def __init__(self, db_path='security_events.db'):
        self.db_path = db_path
        self.event_queue = queue.Queue()
        
        # 각종 탐지기 초기화
        self.parser = LogParser()
        self.frequency_detector = FrequencyDetector(time_window=60, threshold=100)
        self.anomaly_detector = AnomalyDetector()
        self.correlator = MultiSourceCorrelator()
        self.ml_detector = MLBasedDetector()
        
        # 데이터베이스 초기화
        self._init_database()
        
        # 알림 설정
        self.alert_handlers = []
        
    def _init_database(self):
        """데이터베이스 초기화"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS security_events (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                timestamp TEXT NOT NULL,
                event_type TEXT NOT NULL,
                severity TEXT NOT NULL,
                source_ip TEXT,
                details TEXT,
                created_at TEXT DEFAULT CURRENT_TIMESTAMP
            )
        ''')
        
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS blocked_ips (
                ip TEXT PRIMARY KEY,
                reason TEXT,
                blocked_at TEXT DEFAULT CURRENT_TIMESTAMP,
                block_count INTEGER DEFAULT 1
            )
        ''')
        
        conn.commit()
        conn.close()
    
    def add_alert_handler(self, handler):
        """알림 핸들러 추가"""
        self.alert_handlers.append(handler)
    
    def process_log(self, log_entry):
        """로그 처리 및 분석"""
        threats = []
        
        # 1. 빈도 기반 탐지
        is_freq_suspicious, count = self.frequency_detector.check_request(
            log_entry['ip'],
            log_entry['timestamp']
        )
        
        if is_freq_suspicious:
            threats.append({
                'type': 'high_frequency',
                'severity': 'HIGH',
                'details': f'{count}회 요청 (60초 내)'
            })
        
        # 2. 패턴 매칭
        suspicious_patterns = {
            r'\.\./\.\./' : 'Path Traversal',
            r'union.*select': 'SQL Injection',
            r'<script>': 'XSS',
            r'/etc/passwd': 'System File Access',
            r'cmd\.exe': 'Command Execution',
        }
        
        for pattern, attack_type in suspicious_patterns.items():
            if re.search(pattern, log_entry['path'], re.IGNORECASE):
                threats.append({
                    'type': attack_type.lower().replace(' ', '_'),
                    'severity': 'CRITICAL',
                    'details': f'{attack_type} 시도 탐지'
                })
        
        # 3. 이상 징후 탐지
        is_anomaly, anomaly_details = self.anomaly_detector.detect_anomaly(log_entry)
        
        if is_anomaly:
            threats.append({
                'type': 'anomaly',
                'severity': 'MEDIUM',
                'details': ', '.join(anomaly_details)
            })
        
        # 위협이 탐지되면 처리
        if threats:
            self._handle_threats(log_entry, threats)
        
        return threats
    
    def _handle_threats(self, log_entry, threats):
        """위협 처리"""
        ip = log_entry['ip']
        
        # 심각도별 처리
        critical_count = sum(1 for t in threats if t['severity'] == 'CRITICAL')
        
        if critical_count > 0:
            # CRITICAL 위협은 즉시 차단
            self._block_ip(ip, f"Critical threats detected: {critical_count}")
        
        # 데이터베이스에 저장
        for threat in threats:
            self._save_event(
                timestamp=log_entry['timestamp'],
                event_type=threat['type'],
                severity=threat['severity'],
                source_ip=ip,
                details=json.dumps({
                    'threat': threat,
                    'log': log_entry
                })
            )
        
        # 알림 전송
        self._send_alerts(log_entry, threats)
    
    def _block_ip(self, ip, reason):
        """IP 차단"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            INSERT INTO blocked_ips (ip, reason)
            VALUES (?, ?)
            ON CONFLICT(ip) DO UPDATE SET
                block_count = block_count + 1,
                blocked_at = CURRENT_TIMESTAMP
        ''', (ip, reason))
        
        conn.commit()
        conn.close()
        
        print(f"🚫 IP 차단: {ip} - {reason}")
        
        # 실제 방화벽 규칙 추가 (iptables 등)
        # os.system(f"iptables -A INPUT -s {ip} -j DROP")
    
    def _save_event(self, timestamp, event_type, severity, source_ip, details):
        """보안 이벤트 저장"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            INSERT INTO security_events (timestamp, event_type, severity, source_ip, details)
            VALUES (?, ?, ?, ?, ?)
        ''', (timestamp, event_type, severity, source_ip, details))
        
        conn.commit()
        conn.close()
    
    def _send_alerts(self, log_entry, threats):
        """알림 전송"""
        for handler in self.alert_handlers:
            try:
                handler(log_entry, threats)
            except Exception as e:
                print(f"❌ 알림 전송 실패: {str(e)}")
    
    def get_statistics(self, hours=24):
        """통계 조회"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        # 최근 이벤트 수
        cursor.execute('''
            SELECT event_type, severity, COUNT(*) as count
            FROM security_events
            WHERE datetime(created_at) > datetime('now', '-' || ? || ' hours')
            GROUP BY event_type, severity
            ORDER BY count DESC
        ''', (hours,))
        
        events = cursor.fetchall()
        
        # 차단된 IP 수
        cursor.execute('SELECT COUNT(*) FROM blocked_ips')
        blocked_count = cursor.fetchone()[0]
        
        conn.close()
        
        return {
            'events': events,
            'blocked_ips': blocked_count
        }
    
    def start_monitoring(self, log_file):
        """모니터링 시작"""
        print("🚀 보안 모니터링 시스템 시작!")
        print(f"📁 모니터링 파일: {log_file}")
        print("-" * 50)
        
        monitor = RealTimeLogMonitor(log_file, self.process_log)
        
        try:
            monitor.follow()
        except KeyboardInterrupt:
            print("\n\n⏹️ 모니터링 중지")
            self._print_summary()
    
    def _print_summary(self):
        """요약 출력"""
        stats = self.get_statistics(hours=24)
        
        print("\n" + "=" * 50)
        print("📊 24시간 보안 이벤트 요약")
        print("=" * 50)
        
        print("\n🔍 탐지된 이벤트:")
        for event_type, severity, count in stats['events']:
            print(f"   [{severity}] {event_type}: {count}건")
        
        print(f"\n🚫 차단된 IP 수: {stats['blocked_ips']}개")

# 알림 핸들러 예제
def email_alert_handler(log_entry, threats):
    """이메일 알림"""
    print(f"📧 이메일 알림 전송")
    print(f"   수신자: security@company.com")
    print(f"   제목: [보안 경고] {threats[0]['type']} 탐지")
    # 실제로는 smtplib 등을 사용해서 이메일 전송

def slack_alert_handler(log_entry, threats):
    """Slack 알림"""
    print(f"💬 Slack 알림 전송")
    print(f"   채널: #security-alerts")
    # 실제로는 Slack Webhook을 사용해서 메시지 전송

# 시스템 초기화 및 실행
system = SecurityMonitoringSystem()

# 알림 핸들러 등록
system.add_alert_handler(email_alert_handler)
system.add_alert_handler(slack_alert_handler)

# 과거 로그로 학습
print("📚 정상 패턴 학습 중...")
training_logs = system.parser.parse_file('/var/log/apache2/access.log.1')
system.anomaly_detector.learn_profile(training_logs)
system.ml_detector.train(training_logs)

# 모니터링 시작
# system.start_monitoring('/var/log/apache2/access.log')

import matplotlib.pyplot as plt
import seaborn as sns
from collections import Counter

class SecurityDashboard:
    def __init__(self, system):
        self.system = system
        sns.set_style("whitegrid")
        
    def plot_event_timeline(self, hours=24):
        """시간대별 이벤트 그래프"""
        conn = sqlite3.connect(self.system.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            SELECT strftime('%H', created_at) as hour, COUNT(*) as count
            FROM security_events
            WHERE datetime(created_at) > datetime('now', '-' || ? || ' hours')
            GROUP BY hour
            ORDER BY hour
        ''', (hours,))
        
        data = cursor.fetchall()
        conn.close()
        
        if not data:
            print("📊 표시할 데이터가 없습니다.")
            return
        
        hours_list = [int(h) for h, _ in data]
        counts = [c for _, c in data]
        
        plt.figure(figsize=(12, 6))
        plt.bar(hours_list, counts, color='#667eea', alpha=0.7)
        plt.xlabel('시간 (Hour)')
        plt.ylabel('이벤트 수')
        plt.title(f'최근 {hours}시간 보안 이벤트 타임라인')
        plt.xticks(range(24))
        plt.grid(axis='y', alpha=0.3)
        plt.tight_layout()
        plt.savefig('event_timeline.png', dpi=300, bbox_inches='tight')
        print("✅ 그래프 저장: event_timeline.png")
        
    def plot_threat_distribution(self):
        """위협 유형별 분포"""
        conn = sqlite3.connect(self.system.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            SELECT event_type, COUNT(*) as count
            FROM security_events
            GROUP BY event_type
            ORDER BY count DESC
            LIMIT 10
        ''')
        
        data = cursor.fetchall()
        conn.close()
        
        if not data:
            print("📊 표시할 데이터가 없습니다.")
            return
        
        types = [t for t, _ in data]
        counts = [c for _, c in data]
        
        plt.figure(figsize=(10, 8))
        colors = plt.cm.Spectral(range(len(types)))
        plt.pie(counts, labels=types, autopct='%1.1f%%', colors=colors, startangle=90)
        plt.title('위협 유형별 분포')
        plt.axis('equal')
        plt.tight_layout()
        plt.savefig('threat_distribution.png', dpi=300, bbox_inches='tight')
        print("✅ 그래프 저장: threat_distribution.png")
    
    def plot_top_attackers(self, top_n=10):
        """상위 공격자 IP"""
        conn = sqlite3.connect(self.system.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            SELECT source_ip, COUNT(*) as count
            FROM security_events
            WHERE source_ip IS NOT NULL
            GROUP BY source_ip
            ORDER BY count DESC
            LIMIT ?
        ''', (top_n,))
        
        data = cursor.fetchall()
        conn.close()
        
        if not data:
            print("📊 표시할 데이터가 없습니다.")
            return
        
        ips = [ip for ip, _ in data]
        counts = [c for _, c in data]
        
        plt.figure(figsize=(12, 6))
        plt.barh(ips, counts, color='#f87171', alpha=0.7)
        plt.xlabel('이벤트 수')
        plt.ylabel('IP 주소')
        plt.title(f'상위 {top_n}개 공격자 IP')
        plt.gca().invert_yaxis()
        plt.tight_layout()
        plt.savefig('top_attackers.png', dpi=300, bbox_inches='tight')
        print("✅ 그래프 저장: top_attackers.png")
    
    def generate_report(self):
        """종합 리포트 생성"""
        print("\n" + "=" * 60)
        print("📊 보안 모니터링 종합 리포트")
        print("=" * 60)
        
        stats = self.system.get_statistics(hours=24)
        
        print("\n📈 최근 24시간 통계:")
        print(f"   총 이벤트 수: {sum(count for _, _, count in stats['events'])}건")
        print(f"   차단된 IP: {stats['blocked_ips']}개")
        
        print("\n🔥 심각도별 이벤트:")
        severity_counts = {}
        for _, severity, count in stats['events']:
            severity_counts[severity] = severity_counts.get(severity, 0) + count
        
        for severity in ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW']:
            count = severity_counts.get(severity, 0)
            if count > 0:
                print(f"   [{severity}]: {count}건")
        
        print("\n📊 그래프 생성 중...")
        self.plot_event_timeline()
        self.plot_threat_distribution()
        self.plot_top_attackers()
        
        print("\n✅ 리포트 생성 완료!")

# 대시보드 사용
dashboard = SecurityDashboard(system)
dashboard.generate_report()

from multiprocessing import Pool, cpu_count
import os

class ParallelLogProcessor:
    def __init__(self, num_processes=None):
        self.num_processes = num_processes or cpu_count()
        self.parser = LogParser()
        
    def process_chunk(self, chunk):
        """로그 청크 처리"""
        results = []
        for line in chunk:
            parsed = self.parser.parse_line(line.strip())
            if parsed:
                results.append(parsed)
        return results
    
    def split_file(self, filepath, chunk_size=10000):
        """파일을 청크로 분할"""
        chunks = []
        current_chunk = []
        
        with open(filepath, 'r') as f:
            for line in f:
                current_chunk.append(line)
                
                if len(current_chunk) >= chunk_size:
                    chunks.append(current_chunk)
                    current_chunk = []
            
            if current_chunk:
                chunks.append(current_chunk)
        
        return chunks
    
    def process_file_parallel(self, filepath):
        """병렬 처리로 파일 분석"""
        print(f"🚀 {self.num_processes}개 프로세스로 병렬 처리 시작...")
        
        chunks = self.split_file(filepath)
        print(f"📦 {len(chunks)}개 청크로 분할")
        
        with Pool(processes=self.num_processes) as pool:
            results = pool.map(self.process_chunk, chunks)
        
        # 결과 병합
        all_logs = []
        for chunk_result in results:
            all_logs.extend(chunk_result)
        
        print(f"✅ {len(all_logs)}개 로그 처리 완료!")
        return all_logs

# 사용 예제
parallel_processor = ParallelLogProcessor()
logs = parallel_processor.process_file_parallel('/var/log/apache2/access.log')

import redis
import pickle

class CachedLogAnalyzer:
    def __init__(self, redis_host='localhost', redis_port=6379):
        self.redis_client = redis.Redis(host=redis_host, port=redis_port, db=0)
        self.cache_ttl = 3600  # 1시간
        
    def get_cached_analysis(self, cache_key):
        """캐시에서 분석 결과 가져오기"""
        cached = self.redis_client.get(cache_key)
        if cached:
            return pickle.loads(cached)
        return None
    
    def set_cached_analysis(self, cache_key, data):
        """분석 결과 캐싱"""
        self.redis_client.setex(
            cache_key,
            self.cache_ttl,
            pickle.dumps(data)
        )
    
    def analyze_with_cache(self, ip_address):
        """캐시를 활용한 분석"""
        cache_key = f"analysis:{ip_address}"
        
        # 캐시 확인
        cached_result = self.get_cached_analysis(cache_key)
        if cached_result:
            print(f"💾 캐시 히트: {ip_address}")
            return cached_result
        
        # 캐시 미스 - 새로 분석
        print(f"🔍 새로운 분석: {ip_address}")
        result = self._perform_analysis(ip_address)
        
        # 결과 캐싱
        self.set_cached_analysis(cache_key, result)
        
        return result
    
    def _perform_analysis(self, ip_address):
        """실제 분석 수행"""
        # 복잡한 분석 로직...
        return {
            'ip': ip_address,
            'threat_level': 'LOW',
            'analysis_time': datetime.now().isoformat()
        }

class DDoSDetector:
    def __init__(self, threshold_per_second=100):
        self.threshold = threshold_per_second
        self.request_counts = defaultdict(list)
        
    def detect_ddos(self, logs, time_window=10):
        """DDoS 공격 탐지"""
        ddos_sources = []
        
        for log in logs:
            ip = log['ip']
            timestamp = datetime.strptime(log['timestamp'], '%d/%b/%Y:%H:%M:%S %z')
            
            # 요청 기록
            self.request_counts[ip].append(timestamp)
            
            # 오래된 기록 제거
            cutoff = timestamp - timedelta(seconds=time_window)
            self.request_counts[ip] = [
                t for t in self.request_counts[ip] if t > cutoff
            ]
            
            # 초당 요청 수 계산
            requests_per_second = len(self.request_counts[ip]) / time_window
            
            if requests_per_second > self.threshold:
                ddos_sources.append({
                    'ip': ip,
                    'requests_per_second': requests_per_second,
                    'total_requests': len(self.request_counts[ip])
                })
        
        return ddos_sources
    
    def mitigate_ddos(self, sources):
        """DDoS 완화 조치"""
        for source in sources:
            ip = source['ip']
            rps = source['requests_per_second']
            
            print(f"🚨 DDoS 공격 탐지!")
            print(f"   공격자 IP: {ip}")
            print(f"   초당 요청: {rps:.2f}")
            
            # 1. IP 차단
            print(f"   ✅ IP 차단 실행")
            # os.system(f"iptables -A INPUT -s {ip} -j DROP")
            
            # 2. Rate Limiting 적용
            print(f"   ✅ Rate Limiting 적용")
            # nginx rate limit 설정 업데이트
            
            # 3. CDN/WAF에 알림
            print(f"   ✅ CDN/WAF 알림 전송")

# 사용
ddos_detector = DDoSDetector(threshold_per_second=50)
ddos_sources = ddos_detector.detect_ddos(logs)

if ddos_sources:
    ddos_detector.mitigate_ddos(ddos_sources)

class InsiderThreatDetector:
    def __init__(self):
        self.user_baselines = {}
        
    def build_baseline(self, user_id, historical_logs):
        """사용자 정상 행동 패턴 구축"""
        baseline = {
            'typical_hours': set(),
            'typical_ips': set(),
            'typical_actions': set(),
            'avg_data_access': 0,
        }
        
        access_counts = []
        
        for log in historical_logs:
            if log.get('user') == user_id:
                timestamp = datetime.strptime(log['timestamp'], '%d/%b/%Y:%H:%M:%S %z')
                baseline['typical_hours'].add(timestamp.hour)
                baseline['typical_ips'].add(log['ip'])
                baseline['typical_actions'].add(log['method'])
                access_counts.append(int(log.get('size', 0)))
        
        if access_counts:
            baseline['avg_data_access'] = sum(access_counts) / len(access_counts)
        
        self.user_baselines[user_id] = baseline
        
    def detect_insider_threat(self, log):
        """내부자 위협 탐지"""
        user_id = log.get('user')
        
        if not user_id or user_id not in self.user_baselines:
            return False, []
        
        baseline = self.user_baselines[user_id]
        anomalies = []
        
        # 1. 비정상 시간대 접속
        timestamp = datetime.strptime(log['timestamp'], '%d/%b/%Y:%H:%M:%S %z')
        if timestamp.hour not in baseline['typical_hours']:
            anomalies.append(f"비정상 시간대 접속: {timestamp.hour}시")
        
        # 2. 새로운 IP 주소
        if log['ip'] not in baseline['typical_ips']:
            anomalies.append(f"새로운 IP 주소: {log['ip']}")
        
        # 3. 비정상적인 데이터 접근량
        data_size = int(log.get('size', 0))
        if data_size > baseline['avg_data_access'] * 10:  # 평균의 10배
            anomalies.append(f"비정상적인 데이터 접근: {data_size} bytes")
        
        # 4. 민감한 경로 접근
        sensitive_paths = ['/admin', '/api/users', '/backup', '/config']
        if any(path in log['path'] for path in sensitive_paths):
            if log['path'] not in baseline.get('typical_paths', set()):
                anomalies.append(f"민감한 경로 접근: {log['path']}")
        
        return len(anomalies) > 0, anomalies

# 사용
insider_detector = InsiderThreatDetector()

# 과거 로그로 정상 패턴 학습
for user in ['user1', 'user2', 'admin']:
    user_logs = [log for log in historical_logs if log.get('user') == user]
    insider_detector.build_baseline(user, user_logs)

# 실시간 탐지
for log in new_logs:
    is_threat, anomalies = insider_detector.detect_insider_threat(log)
    
    if is_threat:
        print(f"⚠️ 내부자 위협 의심!")
        print(f"   사용자: {log.get('user')}")
        print(f"   이상 징후:")
        for anomaly in anomalies:
            print(f"      - {anomaly}")

import logging
import json

class StructuredLogger:
    def __init__(self, name):
        self.logger = logging.getLogger(name)
        self.logger.setLevel(logging.INFO)
        
        # JSON 포맷 핸들러
        handler = logging.StreamHandler()
        handler.setFormatter(self.JSONFormatter())
        self.logger.addHandler(handler)
    
    class JSONFormatter(logging.Formatter):
        def format(self, record):
            log_data = {
                'timestamp': datetime.now().isoformat(),
                'level': record.levelname,
                'logger': record.name,
                'message': record.getMessage(),
                'module': record.module,
                'function': record.funcName,
                'line': record.lineno
            }
            
            # 추가 컨텍스트 정보
            if hasattr(record, 'user_id'):
                log_data['user_id'] = record.user_id
            if hasattr(record, 'ip_address'):
                log_data['ip_address'] = record.ip_address
            if hasattr(record, 'action'):
                log_data['action'] = record.action
            
            return json.dumps(log_data)
    
    def log_security_event(self, event_type, user_id, ip_address, details):
        """보안 이벤트 로깅"""
        extra = {
            'user_id': user_id,
            'ip_address': ip_address,
            'action': event_type
        }
        
        self.logger.warning(
            f"Security event: {event_type} - {details}",
            extra=extra
        )

# 사용
logger = StructuredLogger('security')
logger.log_security_event(
    event_type='login_failure',
    user_id='user123',
    ip_address='192.168.1.100',
    details='Invalid password'
)

class AlertManager:
    def __init__(self):
        self.alert_history = defaultdict(list)
        self.cooldown_period = 300  # 5분
        
    def should_send_alert(self, alert_type, ip_address):
        """알림 전송 여부 결정"""
        key = f"{alert_type}:{ip_address}"
        now = datetime.now()
        
        # 최근 알림 확인
        recent_alerts = self.alert_history[key]
        recent_alerts = [t for t in recent_alerts 
                        if (now - t).total_seconds() < self.cooldown_period]
        
        if recent_alerts:
            print(f"⏸️ 알림 쿨다운 중: {key}")
            return False
        
        # 알림 기록
        self.alert_history[key].append(now)
        return True
    
    def send_alert(self, alert_type, ip_address, details):
        """알림 전송"""
        if self.should_send_alert(alert_type, ip_address):
            print(f"🔔 알림 전송: {alert_type}")
            print(f"   IP: {ip_address}")
            print(f"   상세: {details}")
            # 실제 알림 전송 로직
        else:
            print(f"⏭️ 알림 스킵 (쿨다운)")

alert_manager = AlertManager()
alert_manager.send_alert('sql_injection', '192.168.1.100', 'Detected in /api/users')

class SystemHealthChecker:
    def __init__(self, system):
        self.system = system
        
    def check_health(self):
        """시스템 건강 상태 체크"""
        issues = []
        
        # 1. 디스크 공간 체크
        disk_usage = self._check_disk_space()
        if disk_usage > 80:
            issues.append(f"디스크 사용률 높음: {disk_usage}%")
        
        # 2. 로그 파일 접근 가능 여부
        if not self._check_log_file_access():
            issues.append("로그 파일 접근 불가")
        
        # 3. 데이터베이스 연결
        if not self._check_database_connection():
            issues.append("데이터베이스 연결 실패")
        
        # 4. 최근 이벤트 처리 확인
        last_event_time = self._get_last_event_time()
        if last_event_time:
            time_diff = (datetime.now() - last_event_time).total_seconds()
            if time_diff > 600:  # 10분
                issues.append(f"최근 이벤트 없음 ({time_diff/60:.1f}분)")
        
        return len(issues) == 0, issues
    
    def _check_disk_space(self):
        """디스크 공간 체크"""
        import shutil
        total, used, free = shutil.disk_usage("/")
        return (used / total) * 100
    
    def _check_log_file_access(self):
        """로그 파일 접근 체크"""
        try:
            with open('/var/log/apache2/access.log', 'r') as f:
                f.read(1)
            return True
        except:
            return False
    
    def _check_database_connection(self):
        """데이터베이스 연결 체크"""
        try:
            conn = sqlite3.connect(self.system.db_path)
            conn.execute('SELECT 1')
            conn.close()
            return True
        except:
            return False
    
    def _get_last_event_time(self):
        """마지막 이벤트 시간"""
        try:
            conn = sqlite3.connect(self.system.db_path)
            cursor = conn.cursor()
            cursor.execute('SELECT MAX(created_at) FROM security_events')
            result = cursor.fetchone()[0]
            conn.close()
            
            if result:
                return datetime.fromisoformat(result)
        except:
            pass
        return None

# 정기 점검 실행
health_checker = SystemHealthChecker(system)
is_healthy, issues = health_checker.check_health()

if not is_healthy:
    print("⚠️ 시스템 건강 상태 이상!")
    for issue in issues:
        print(f"   - {issue}")
else:
    print("✅ 시스템 정상 작동 중")