Windows Forensics - Расследование инцидентов на Windows

Что такое Windows Forensics?

Windows Forensics — это специализированная область цифровой криминалистики, фокусирующаяся на расследовании инцидентов безопасности в операционных системах Windows. Включает анализ логов, реестра, файловой системы, памяти и сетевой активности.

Основные принципы

Systematic Approach — системный подход
Evidence Preservation — сохранение доказательств
Timeline Analysis — анализ временных меток
Artifact Correlation — корреляция артефактов
Legal Admissibility — правовая допустимость

Архитектура Windows Forensics

1. Log Analysis

// Система анализа логов Windows
class WindowsLogAnalyzer {
  constructor() {
    this.logs = new Map();
    this.events = new Map();
    this.patterns = new Map();
    this.correlations = new Map();
  }

  // Анализ Event Log
  analyzeEventLog(logData) {
    const analysis = {
      id: this.generateAnalysisId(),
      logType: logData.logType, // SYSTEM, SECURITY, APPLICATION
      timeRange: logData.timeRange,
      events: [],
      anomalies: [],
      correlations: [],
      summary: {
        totalEvents: 0,
        criticalEvents: 0,
        warningEvents: 0,
        infoEvents: 0,
      },
    };

    // Парсинг событий
    const events = this.parseEvents(logData.content);
    analysis.events = events;

    // Анализ аномалий
    const anomalies = this.findAnomalies(events);
    analysis.anomalies = anomalies;

    // Корреляция событий
    const correlations = this.correlateEvents(events);
    analysis.correlations = correlations;

    // Расчет сводки
    this.calculateSummary(analysis);

    return analysis;
  }

  // Парсинг событий
  parseEvents(logContent) {
    const events = [];
    const lines = logContent.split("\n");

    for (const line of lines) {
      if (line.trim()) {
        const event = this.parseEventLine(line);
        if (event) {
          events.push(event);
        }
      }
    }

    return events;
  }

  // Парсинг строки события
  parseEventLine(line) {
    // Упрощенный парсинг Event Log
    const parts = line.split("\t");
    if (parts.length < 6) return null;

    return {
      timestamp: new Date(parts[0]),
      level: parts[1],
      source: parts[2],
      eventId: parseInt(parts[3]),
      category: parts[4],
      message: parts[5],
      computer: parts[6] || "Unknown",
    };
  }

  // Поиск аномалий
  findAnomalies(events) {
    const anomalies = [];

    // Аномальные времена входа
    const loginAnomalies = this.findLoginAnomalies(events);
    anomalies.push(...loginAnomalies);

    // Подозрительная активность
    const suspiciousActivity = this.findSuspiciousActivity(events);
    anomalies.push(...suspiciousActivity);

    // Ошибки безопасности
    const securityErrors = this.findSecurityErrors(events);
    anomalies.push(...securityErrors);

    return anomalies;
  }

  // Поиск аномалий входа
  findLoginAnomalies(events) {
    const anomalies = [];
    const loginEvents = events.filter(
      (e) => e.eventId === 4624 || e.eventId === 4625
    );

    // Группировка по пользователям
    const userLogins = this.groupByUser(loginEvents);

    for (const [user, logins] of userLogins) {
      // Проверка на множественные неудачные попытки
      const failedLogins = logins.filter((l) => l.eventId === 4625);
      if (failedLogins.length > 5) {
        anomalies.push({
          type: "MULTIPLE_FAILED_LOGINS",
          user: user,
          count: failedLogins.length,
          severity: "HIGH",
          description: `User ${user} has ${failedLogins.length} failed login attempts`,
        });
      }

      // Проверка на входы в необычное время
      const unusualTimeLogins = this.findUnusualTimeLogins(logins);
      if (unusualTimeLogins.length > 0) {
        anomalies.push({
          type: "UNUSUAL_TIME_LOGIN",
          user: user,
          count: unusualTimeLogins.length,
          severity: "MEDIUM",
          description: `User ${user} has ${unusualTimeLogins.length} logins outside business hours`,
        });
      }
    }

    return anomalies;
  }

  // Поиск подозрительной активности
  findSuspiciousActivity(events) {
    const anomalies = [];

    // События изменения привилегий
    const privilegeEvents = events.filter((e) => e.eventId === 4672);
    if (privilegeEvents.length > 0) {
      anomalies.push({
        type: "PRIVILEGE_ESCALATION",
        count: privilegeEvents.length,
        severity: "HIGH",
        description: `Detected ${privilegeEvents.length} privilege escalation events`,
      });
    }

    // События изменения политик
    const policyEvents = events.filter((e) => e.eventId === 4719);
    if (policyEvents.length > 0) {
      anomalies.push({
        type: "POLICY_CHANGES",
        count: policyEvents.length,
        severity: "MEDIUM",
        description: `Detected ${policyEvents.length} policy change events`,
      });
    }

    // События очистки логов
    const logClearEvents = events.filter((e) => e.eventId === 1102);
    if (logClearEvents.length > 0) {
      anomalies.push({
        type: "LOG_CLEARED",
        count: logClearEvents.length,
        severity: "HIGH",
        description: `Detected ${logClearEvents.length} log clearing events`,
      });
    }

    return anomalies;
  }

  // Поиск ошибок безопасности
  findSecurityErrors(events) {
    const anomalies = [];

    // Критические ошибки безопасности
    const criticalErrors = events.filter(
      (e) =>
        e.level === "ERROR" &&
        e.source === "Microsoft-Windows-Security-Auditing"
    );

    if (criticalErrors.length > 0) {
      anomalies.push({
        type: "SECURITY_ERRORS",
        count: criticalErrors.length,
        severity: "HIGH",
        description: `Detected ${criticalErrors.length} critical security errors`,
      });
    }

    return anomalies;
  }

  // Корреляция событий
  correlateEvents(events) {
    const correlations = [];

    // Корреляция по времени
    const timeCorrelations = this.correlateByTime(events);
    correlations.push(...timeCorrelations);

    // Корреляция по пользователям
    const userCorrelations = this.correlateByUser(events);
    correlations.push(...userCorrelations);

    // Корреляция по IP адресам
    const ipCorrelations = this.correlateByIP(events);
    correlations.push(...ipCorrelations);

    return correlations;
  }

  // Корреляция по времени
  correlateByTime(events) {
    const correlations = [];
    const timeGroups = this.groupByTime(events, 300000); // 5 минут

    for (const [timeSlot, slotEvents] of timeGroups) {
      if (slotEvents.length > 10) {
        correlations.push({
          type: "TIME_CORRELATION",
          timeSlot: timeSlot,
          eventCount: slotEvents.length,
          description: `High activity detected at ${timeSlot}`,
        });
      }
    }

    return correlations;
  }

  // Генерация ID анализа
  generateAnalysisId() {
    return (
      "LOG-ANALYSIS-" +
      Date.now() +
      "-" +
      Math.random().toString(36).substr(2, 4)
    );
  }
}

2. Registry Analysis

// Система анализа реестра Windows
class WindowsRegistryAnalyzer {
  constructor() {
    this.registry = new Map();
    this.hives = new Map();
    this.keys = new Map();
    this.artifacts = new Map();
  }

  // Анализ кустов реестра
  analyzeRegistryHive(hiveData) {
    const analysis = {
      id: this.generateAnalysisId(),
      hive: hiveData.hive, // HKLM, HKCU, HKU, HKCR
      timeRange: hiveData.timeRange,
      keys: [],
      values: [],
      artifacts: [],
      anomalies: [],
      summary: {
        totalKeys: 0,
        totalValues: 0,
        suspiciousKeys: 0,
        suspiciousValues: 0,
      },
    };

    // Парсинг куста реестра
    const parsedHive = this.parseRegistryHive(hiveData.content);
    analysis.keys = parsedHive.keys;
    analysis.values = parsedHive.values;

    // Поиск артефактов
    const artifacts = this.findRegistryArtifacts(parsedHive);
    analysis.artifacts = artifacts;

    // Поиск аномалий
    const anomalies = this.findRegistryAnomalies(parsedHive);
    analysis.anomalies = anomalies;

    // Расчет сводки
    this.calculateRegistrySummary(analysis);

    return analysis;
  }

  // Парсинг куста реестра
  parseRegistryHive(content) {
    const keys = [];
    const values = [];

    // Упрощенный парсинг реестра
    const lines = content.split("\n");
    let currentKey = null;

    for (const line of lines) {
      if (line.startsWith("[") && line.endsWith("]")) {
        // Ключ реестра
        currentKey = {
          path: line.slice(1, -1),
          values: [],
        };
        keys.push(currentKey);
      } else if (currentKey && line.includes("=")) {
        // Значение реестра
        const [name, value] = line.split("=", 2);
        const registryValue = {
          key: currentKey.path,
          name: name.trim(),
          value: value.trim(),
          type: this.detectValueType(value.trim()),
        };
        values.push(registryValue);
        currentKey.values.push(registryValue);
      }
    }

    return { keys, values };
  }

  // Определение типа значения
  detectValueType(value) {
    if (value.startsWith('"') && value.endsWith('"')) {
      return "STRING";
    } else if (value.startsWith("dword:")) {
      return "DWORD";
    } else if (value.startsWith("hex:")) {
      return "BINARY";
    } else {
      return "UNKNOWN";
    }
  }

  // Поиск артефактов реестра
  findRegistryArtifacts(parsedHive) {
    const artifacts = [];

    // Автозапуск приложений
    const autorunArtifacts = this.findAutorunArtifacts(parsedHive);
    artifacts.push(...autorunArtifacts);

    // Недавно использованные файлы
    const mruArtifacts = this.findMRUArtifacts(parsedHive);
    artifacts.push(...mruArtifacts);

    // Сетевые подключения
    const networkArtifacts = this.findNetworkArtifacts(parsedHive);
    artifacts.push(...networkArtifacts);

    // Установленные программы
    const programArtifacts = this.findProgramArtifacts(parsedHive);
    artifacts.push(...programArtifacts);

    return artifacts;
  }

  // Поиск артефактов автозапуска
  findAutorunArtifacts(parsedHive) {
    const artifacts = [];
    const autorunKeys = [
      "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",
      "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce",
      "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunServices",
      "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunServicesOnce",
    ];

    for (const keyPath of autorunKeys) {
      const key = parsedHive.keys.find((k) => k.path.includes(keyPath));
      if (key) {
        for (const value of key.values) {
          artifacts.push({
            type: "AUTORUN",
            key: keyPath,
            name: value.name,
            value: value.value,
            description: `Autorun entry: ${value.name} = ${value.value}`,
          });
        }
      }
    }

    return artifacts;
  }

  // Поиск артефактов MRU
  findMRUArtifacts(parsedHive) {
    const artifacts = [];
    const mruKeys = parsedHive.keys.filter((k) => k.path.includes("MRU"));

    for (const key of mruKeys) {
      for (const value of key.values) {
        artifacts.push({
          type: "MRU",
          key: key.path,
          name: value.name,
          value: value.value,
          description: `Recently used: ${value.value}`,
        });
      }
    }

    return artifacts;
  }

  // Поиск сетевых артефактов
  findNetworkArtifacts(parsedHive) {
    const artifacts = [];
    const networkKeys = parsedHive.keys.filter(
      (k) => k.path.includes("Network") || k.path.includes("Internet")
    );

    for (const key of networkKeys) {
      for (const value of key.values) {
        artifacts.push({
          type: "NETWORK",
          key: key.path,
          name: value.name,
          value: value.value,
          description: `Network configuration: ${value.name} = ${value.value}`,
        });
      }
    }

    return artifacts;
  }

  // Поиск артефактов программ
  findProgramArtifacts(parsedHive) {
    const artifacts = [];
    const programKeys = parsedHive.keys.filter((k) =>
      k.path.includes("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall")
    );

    for (const key of programKeys) {
      const programName = key.values.find((v) => v.name === "DisplayName");
      const programVersion = key.values.find(
        (v) => v.name === "DisplayVersion"
      );

      if (programName) {
        artifacts.push({
          type: "PROGRAM",
          key: key.path,
          name: programName.value,
          version: programVersion ? programVersion.value : "Unknown",
          description: `Installed program: ${programName.value}`,
        });
      }
    }

    return artifacts;
  }

  // Поиск аномалий реестра
  findRegistryAnomalies(parsedHive) {
    const anomalies = [];

    // Подозрительные ключи
    const suspiciousKeys = this.findSuspiciousKeys(parsedHive);
    anomalies.push(...suspiciousKeys);

    // Подозрительные значения
    const suspiciousValues = this.findSuspiciousValues(parsedHive);
    anomalies.push(...suspiciousValues);

    // Изменения в критических ключах
    const criticalChanges = this.findCriticalChanges(parsedHive);
    anomalies.push(...criticalChanges);

    return anomalies;
  }

  // Поиск подозрительных ключей
  findSuspiciousKeys(parsedHive) {
    const anomalies = [];
    const suspiciousPatterns = [/temp/i, /tmp/i, /cache/i, /temp/i];

    for (const key of parsedHive.keys) {
      for (const pattern of suspiciousPatterns) {
        if (pattern.test(key.path)) {
          anomalies.push({
            type: "SUSPICIOUS_KEY",
            key: key.path,
            severity: "MEDIUM",
            description: `Suspicious key path: ${key.path}`,
          });
        }
      }
    }

    return anomalies;
  }

  // Поиск подозрительных значений
  findSuspiciousValues(parsedHive) {
    const anomalies = [];
    const suspiciousPatterns = [
      /cmd\.exe/i,
      /powershell\.exe/i,
      /wscript\.exe/i,
      /cscript\.exe/i,
    ];

    for (const value of parsedHive.values) {
      for (const pattern of suspiciousPatterns) {
        if (pattern.test(value.value)) {
          anomalies.push({
            type: "SUSPICIOUS_VALUE",
            key: value.key,
            name: value.name,
            value: value.value,
            severity: "HIGH",
            description: `Suspicious value: ${value.name} = ${value.value}`,
          });
        }
      }
    }

    return anomalies;
  }

  // Генерация ID анализа
  generateAnalysisId() {
    return (
      "REG-ANALYSIS-" +
      Date.now() +
      "-" +
      Math.random().toString(36).substr(2, 4)
    );
  }
}

3. File System Analysis

// Система анализа файловой системы Windows
class WindowsFileSystemAnalyzer {
  constructor() {
    this.files = new Map();
    this.directories = new Map();
    this.timeline = new Map();
    this.artifacts = new Map();
  }

  // Анализ файловой системы
  analyzeFileSystem(fsData) {
    const analysis = {
      id: this.generateAnalysisId(),
      drive: fsData.drive,
      timeRange: fsData.timeRange,
      files: [],
      directories: [],
      timeline: [],
      artifacts: [],
      anomalies: [],
      summary: {
        totalFiles: 0,
        totalDirectories: 0,
        suspiciousFiles: 0,
        deletedFiles: 0,
      },
    };

    // Парсинг файловой системы
    const parsedFS = this.parseFileSystem(fsData.content);
    analysis.files = parsedFS.files;
    analysis.directories = parsedFS.directories;

    // Создание временной шкалы
    const timeline = this.createTimeline(parsedFS);
    analysis.timeline = timeline;

    // Поиск артефактов
    const artifacts = this.findFileSystemArtifacts(parsedFS);
    analysis.artifacts = artifacts;

    // Поиск аномалий
    const anomalies = this.findFileSystemAnomalies(parsedFS);
    analysis.anomalies = anomalies;

    // Расчет сводки
    this.calculateFileSystemSummary(analysis);

    return analysis;
  }

  // Парсинг файловой системы
  parseFileSystem(content) {
    const files = [];
    const directories = [];
    const lines = content.split("\n");

    for (const line of lines) {
      if (line.trim()) {
        const entry = this.parseFileSystemEntry(line);
        if (entry) {
          if (entry.type === "FILE") {
            files.push(entry);
          } else if (entry.type === "DIRECTORY") {
            directories.push(entry);
          }
        }
      }
    }

    return { files, directories };
  }

  // Парсинг записи файловой системы
  parseFileSystemEntry(line) {
    // Упрощенный парсинг вывода dir /s
    const parts = line.split(/\s+/);
    if (parts.length < 4) return null;

    const dateStr = parts[0];
    const timeStr = parts[1];
    const sizeStr = parts[2];
    const name = parts.slice(3).join(" ");

    if (name === "." || name === "..") return null;

    const isDirectory = sizeStr === "<DIR>";
    const size = isDirectory ? 0 : parseInt(sizeStr.replace(/,/g, "));

    return {
      name: name,
      path: name,
      type: isDirectory ? "DIRECTORY" : "FILE",
      size: size,
      created: new Date(`${dateStr} ${timeStr}`),
      modified: new Date(`${dateStr} ${timeStr}`),
      accessed: new Date(`${dateStr} ${timeStr}`),
    };
  }

  // Создание временной шкалы
  createTimeline(parsedFS) {
    const timeline = [];

    // Объединение файлов и директорий
    const allEntries = [...parsedFS.files, ...parsedFS.directories];

    // Сортировка по времени
    allEntries.sort((a, b) => a.modified - b.modified);

    // Группировка по времени
    const timeGroups = this.groupByTime(allEntries, 3600000); // 1 час

    for (const [timeSlot, entries] of timeGroups) {
      timeline.push({
        time: timeSlot,
        entries: entries,
        count: entries.length,
      });
    }

    return timeline;
  }

  // Поиск артефактов файловой системы
  findFileSystemArtifacts(parsedFS) {
    const artifacts = [];

    // Временные файлы
    const tempFiles = this.findTempFiles(parsedFS.files);
    artifacts.push(...tempFiles);

    // Системные файлы
    const systemFiles = this.findSystemFiles(parsedFS.files);
    artifacts.push(...systemFiles);

    // Пользовательские файлы
    const userFiles = this.findUserFiles(parsedFS.files);
    artifacts.push(...userFiles);

    // Сетевые файлы
    const networkFiles = this.findNetworkFiles(parsedFS.files);
    artifacts.push(...networkFiles);

    return artifacts;
  }

  // Поиск временных файлов
  findTempFiles(files) {
    const artifacts = [];
    const tempPatterns = [/\.tmp$/i, /\.temp$/i, /temp/i, /cache/i];

    for (const file of files) {
      for (const pattern of tempPatterns) {
        if (pattern.test(file.name) || pattern.test(file.path)) {
          artifacts.push({
            type: "TEMP_FILE",
            file: file,
            description: `Temporary file: ${file.name}`,
          });
        }
      }
    }

    return artifacts;
  }

  // Поиск системных файлов
  findSystemFiles(files) {
    const artifacts = [];
    const systemPatterns = [/\.dll$/i, /\.exe$/i, /\.sys$/i, /\.drv$/i];

    for (const file of files) {
      for (const pattern of systemPatterns) {
        if (pattern.test(file.name)) {
          artifacts.push({
            type: "SYSTEM_FILE",
            file: file,
            description: `System file: ${file.name}`,
          });
        }
      }
    }

    return artifacts;
  }

  // Поиск пользовательских файлов
  findUserFiles(files) {
    const artifacts = [];
    const userPatterns = [/Documents/i, /Desktop/i, /Downloads/i, /Pictures/i];

    for (const file of files) {
      for (const pattern of userPatterns) {
        if (pattern.test(file.path)) {
          artifacts.push({
            type: "USER_FILE",
            file: file,
            description: `User file: ${file.name}`,
          });
        }
      }
    }

    return artifacts;
  }

  // Поиск сетевых файлов
  findNetworkFiles(files) {
    const artifacts = [];
    const networkPatterns = [/\.log$/i, /\.pcap$/i, /\.cap$/i, /network/i];

    for (const file of files) {
      for (const pattern of networkPatterns) {
        if (pattern.test(file.name) || pattern.test(file.path)) {
          artifacts.push({
            type: "NETWORK_FILE",
            file: file,
            description: `Network file: ${file.name}`,
          });
        }
      }
    }

    return artifacts;
  }

  // Генерация ID анализа
  generateAnalysisId() {
    return (
      "FS-ANALYSIS-" +
      Date.now() +
      "-" +
      Math.random().toString(36).substr(2, 4)
    );
  }
}

Основные компоненты Windows Forensics

1. Log Analysis

Event Logs — журналы событий
Security Logs — журналы безопасности
Application Logs — журналы приложений
System Logs — системные журналы

2. Registry Analysis

Hive Analysis — анализ кустов реестра
Key Analysis — анализ ключей
Value Analysis — анализ значений
Timeline Analysis — анализ временных меток

3. File System Analysis

File Analysis — анализ файлов
Directory Analysis — анализ директорий
Timeline Analysis — анализ временных меток
Artifact Analysis — анализ артефактов

Best Practices

1. Evidence Collection

Live Response — живой ответ
Memory Dump — дамп памяти
Disk Image — образ диска
Network Capture — захват сети

2. Analysis

Timeline Analysis — анализ временных меток
Correlation — корреляция данных
Pattern Recognition — распознавание паттернов
Anomaly Detection — обнаружение аномалий

3. Documentation

Chain of Custody — цепочка хранения
Analysis Notes — заметки анализа
Findings Report — отчет о находках
Legal Documentation — правовая документация

Заключение

Windows Forensics — это специализированная область цифровой криминалистики, которая требует:

Глубокого понимания — операционной системы Windows
Системного подхода — к анализу данных
Специализированных инструментов — для анализа
Правовых знаний — для обеспечения допустимости доказательств

Помните: Windows Forensics — это не разовое мероприятие, а постоянный процесс. Регулярно обновляйте инструменты, следите за новыми угрозами и адаптируйте методы анализа.

Совет: Начните с анализа логов событий, затем переходите к анализу реестра и файловой системы. Не забывайте о создании временных шкал и корреляции данных!