Network Traffic Analysis - Анализ сетевого трафика

Что такое Network Traffic Analysis?

Network Traffic Analysis — это процесс анализа сетевого трафика для выявления угроз безопасности, аномалий, производительности и соответствия политикам. Включает анализ PCAP файлов, использование инструментов как Wireshark и Tcpdump, а также анализ различных сетевых протоколов.

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

• Packet Capture — захват пакетов
• Protocol Analysis — анализ протоколов
• Anomaly Detection — обнаружение аномалий
• Threat Detection — обнаружение угроз
• Performance Analysis — анализ производительности

Архитектура Network Traffic Analysis

1. PCAP Analysis

// Система анализа PCAP файлов
class PCAPAnalyzer {
  constructor() {
    this.packets = new Map();
    this.flows = new Map();
    this.protocols = new Map();
    this.anomalies = new Map();
  }

  // Анализ PCAP файла
  analyzePCAP(pcapData) {
    const analysis = {
      id: this.generateAnalysisId(),
      file: pcapData.file,
      timeRange: pcapData.timeRange,
      packets: [],
      flows: [],
      protocols: [],
      anomalies: [],
      summary: {
        totalPackets: 0,
        totalFlows: 0,
        totalProtocols: 0,
        totalAnomalies: 0,
      },
    };

    // Парсинг пакетов
    const packets = this.parsePackets(pcapData.content);
    analysis.packets = packets;

    // Анализ потоков
    const flows = this.analyzeFlows(packets);
    analysis.flows = flows;

    // Анализ протоколов
    const protocols = this.analyzeProtocols(packets);
    analysis.protocols = protocols;

    // Поиск аномалий
    const anomalies = this.findAnomalies(packets, flows);
    analysis.anomalies = anomalies;

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

    return analysis;
  }

  // Парсинг пакетов
  parsePackets(content) {
    const packets = [];
    const lines = content.split("\n");

    for (let i = 0; i < lines.length; i++) {
      const line = lines[i].trim();
      if (line) {
        const packet = this.parsePacketLine(line, i + 1);
        if (packet) {
          packets.push(packet);
        }
      }
    }

    return packets;
  }

  // Парсинг строки пакета
  parsePacketLine(line, lineNumber) {
    // Упрощенный парсинг вывода tcpdump
    const parts = line.split(/\s+/);
    if (parts.length < 6) return null;

    const timestamp = parts[0];
    const source = parts[1];
    const direction = parts[2];
    const destination = parts[3];
    const protocol = parts[4];
    const info = parts.slice(5).join(" ");

    return {
      id: this.generatePacketId(),
      timestamp: new Date(timestamp),
      source: source,
      destination: destination,
      protocol: protocol,
      info: info,
      line: lineNumber,
      size: this.extractPacketSize(info),
      flags: this.extractFlags(info),
    };
  }

  // Извлечение размера пакета
  extractPacketSize(info) {
    const sizeMatch = info.match(/(\d+)\s+bytes/);
    return sizeMatch ? parseInt(sizeMatch[1]) : 0;
  }

  // Извлечение флагов
  extractFlags(info) {
    const flags = [];
    if (info.includes("SYN")) flags.push("SYN");
    if (info.includes("ACK")) flags.push("ACK");
    if (info.includes("FIN")) flags.push("FIN");
    if (info.includes("RST")) flags.push("RST");
    if (info.includes("PSH")) flags.push("PSH");
    if (info.includes("URG")) flags.push("URG");
    return flags;
  }

  // Анализ потоков
  analyzeFlows(packets) {
    const flows = new Map();

    for (const packet of packets) {
      const flowKey = this.generateFlowKey(packet);

      if (!flows.has(flowKey)) {
        flows.set(flowKey, {
          id: this.generateFlowId(),
          source: packet.source,
          destination: packet.destination,
          protocol: packet.protocol,
          packets: [],
          startTime: packet.timestamp,
          endTime: packet.timestamp,
          totalBytes: 0,
          packetCount: 0,
        });
      }

      const flow = flows.get(flowKey);
      flow.packets.push(packet);
      flow.endTime = packet.timestamp;
      flow.totalBytes += packet.size;
      flow.packetCount++;
    }

    return Array.from(flows.values());
  }

  // Генерация ключа потока
  generateFlowKey(packet) {
    const source = packet.source;
    const destination = packet.destination;
    const protocol = packet.protocol;

    // Сортировка для обеспечения консистентности
    const sorted = [source, destination].sort();
    return `${sorted[0]}-${sorted[1]}-${protocol}`;
  }

  // Анализ протоколов
  analyzeProtocols(packets) {
    const protocolStats = new Map();

    for (const packet of packets) {
      const protocol = packet.protocol;

      if (!protocolStats.has(protocol)) {
        protocolStats.set(protocol, {
          name: protocol,
          packetCount: 0,
          totalBytes: 0,
          flows: new Set(),
        });
      }

      const stats = protocolStats.get(protocol);
      stats.packetCount++;
      stats.totalBytes += packet.size;
      stats.flows.add(this.generateFlowKey(packet));
    }

    // Конвертация в массив
    const protocols = Array.from(protocolStats.values()).map((stats) => ({
      name: stats.name,
      packetCount: stats.packetCount,
      totalBytes: stats.totalBytes,
      flowCount: stats.flows.size,
      averagePacketSize: stats.totalBytes / stats.packetCount,
    }));

    return protocols;
  }

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

    // Аномалии в пакетах
    const packetAnomalies = this.findPacketAnomalies(packets);
    anomalies.push(...packetAnomalies);

    // Аномалии в потоках
    const flowAnomalies = this.findFlowAnomalies(flows);
    anomalies.push(...flowAnomalies);

    // Аномалии в протоколах
    const protocolAnomalies = this.findProtocolAnomalies(packets);
    anomalies.push(...protocolAnomalies);

    return anomalies;
  }

  // Поиск аномалий в пакетах
  findPacketAnomalies(packets) {
    const anomalies = [];

    // Аномально большие пакеты
    const largePackets = packets.filter((p) => p.size > 1500);
    if (largePackets.length > 0) {
      anomalies.push({
        type: "LARGE_PACKETS",
        count: largePackets.length,
        severity: "MEDIUM",
        description: `Found ${largePackets.length} packets larger than 1500 bytes`,
      });
    }

    // Аномально маленькие пакеты
    const smallPackets = packets.filter((p) => p.size < 64);
    if (smallPackets.length > 0) {
      anomalies.push({
        type: "SMALL_PACKETS",
        count: smallPackets.length,
        severity: "LOW",
        description: `Found ${smallPackets.length} packets smaller than 64 bytes`,
      });
    }

    // Пакеты с подозрительными флагами
    const suspiciousFlags = packets.filter(
      (p) => p.flags.includes("RST") && p.flags.includes("SYN")
    );
    if (suspiciousFlags.length > 0) {
      anomalies.push({
        type: "SUSPICIOUS_FLAGS",
        count: suspiciousFlags.length,
        severity: "HIGH",
        description: `Found ${suspiciousFlags.length} packets with suspicious flag combinations`,
      });
    }

    return anomalies;
  }

  // Поиск аномалий в потоках
  findFlowAnomalies(flows) {
    const anomalies = [];

    // Потоки с большим количеством пакетов
    const highPacketFlows = flows.filter((f) => f.packetCount > 1000);
    if (highPacketFlows.length > 0) {
      anomalies.push({
        type: "HIGH_PACKET_FLOWS",
        count: highPacketFlows.length,
        severity: "MEDIUM",
        description: `Found ${highPacketFlows.length} flows with more than 1000 packets`,
      });
    }

    // Потоки с большим объемом данных
    const highByteFlows = flows.filter((f) => f.totalBytes > 1000000);
    if (highByteFlows.length > 0) {
      anomalies.push({
        type: "HIGH_BYTE_FLOWS",
        count: highByteFlows.length,
        severity: "MEDIUM",
        description: `Found ${highByteFlows.length} flows with more than 1MB of data`,
      });
    }

    // Долгие потоки
    const longFlows = flows.filter(
      (f) => f.endTime - f.startTime > 3600000 // 1 час
    );
    if (longFlows.length > 0) {
      anomalies.push({
        type: "LONG_FLOWS",
        count: longFlows.length,
        severity: "LOW",
        description: `Found ${longFlows.length} flows longer than 1 hour`,
      });
    }

    return anomalies;
  }

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

  // Генерация ID пакета
  generatePacketId() {
    return (
      "PACKET-" + Date.now() + "-" + Math.random().toString(36).substr(2, 4)
    );
  }

  // Генерация ID потока
  generateFlowId() {
    return "FLOW-" + Date.now() + "-" + Math.random().toString(36).substr(2, 4);
  }
}

2. Wireshark Integration

// Система интеграции с Wireshark
class WiresharkIntegration {
  constructor() {
    this.filters = new Map();
    this.displays = new Map();
    this.statistics = new Map();
    this.exports = new Map();
  }

  // Создание фильтров Wireshark
  createWiresharkFilters(trafficData) {
    const filters = [];

    // Фильтр по протоколу
    const protocolFilters = this.createProtocolFilters(trafficData.protocols);
    filters.push(...protocolFilters);

    // Фильтр по IP адресам
    const ipFilters = this.createIPFilters(trafficData.flows);
    filters.push(...ipFilters);

    // Фильтр по портам
    const portFilters = this.createPortFilters(trafficData.flows);
    filters.push(...portFilters);

    // Фильтр по времени
    const timeFilters = this.createTimeFilters(trafficData.timeRange);
    filters.push(...timeFilters);

    return filters;
  }

  // Создание фильтров по протоколам
  createProtocolFilters(protocols) {
    const filters = [];

    for (const protocol of protocols) {
      const filter = {
        name: `${protocol.name} Protocol`,
        expression: `proto ${protocol.name.toLowerCase()}`,
        description: `Filter for ${protocol.name} protocol traffic`,
        category: "PROTOCOL",
      };
      filters.push(filter);
    }

    return filters;
  }

  // Создание фильтров по IP адресам
  createIPFilters(flows) {
    const filters = [];
    const ips = new Set();

    for (const flow of flows) {
      ips.add(flow.source);
      ips.add(flow.destination);
    }

    for (const ip of ips) {
      const filter = {
        name: `IP ${ip}`,
        expression: `ip.addr == ${ip}`,
        description: `Filter for traffic involving IP ${ip}`,
        category: "IP",
      };
      filters.push(filter);
    }

    return filters;
  }

  // Создание фильтров по портам
  createPortFilters(flows) {
    const filters = [];
    const ports = new Set();

    for (const flow of flows) {
      if (flow.protocol === "TCP" || flow.protocol === "UDP") {
        const sourcePort = this.extractPort(flow.source);
        const destPort = this.extractPort(flow.destination);

        if (sourcePort) ports.add(sourcePort);
        if (destPort) ports.add(destPort);
      }
    }

    for (const port of ports) {
      const filter = {
        name: `Port ${port}`,
        expression: `tcp.port == ${port} or udp.port == ${port}`,
        description: `Filter for traffic on port ${port}`,
        category: "PORT",
      };
      filters.push(filter);
    }

    return filters;
  }

  // Извлечение порта из адреса
  extractPort(address) {
    const portMatch = address.match(/:(\d+)$/);
    return portMatch ? parseInt(portMatch[1]) : null;
  }

  // Создание фильтров по времени
  createTimeFilters(timeRange) {
    const filters = [];

    if (timeRange.start && timeRange.end) {
      const startTime = timeRange.start.toISOString();
      const endTime = timeRange.end.toISOString();

      const filter = {
        name: "Time Range",
        expression: `frame.time >= "${startTime}" and frame.time <= "${endTime}"`,
        description: `Filter for traffic between ${startTime} and ${endTime}`,
        category: "TIME",
      };
      filters.push(filter);
    }

    return filters;
  }

  // Экспорт в формат Wireshark
  exportToWireshark(analysis) {
    const exportData = {
      version: "1.0",
      timestamp: new Date(),
      analysis: analysis,
      filters: this.createWiresharkFilters(analysis),
      statistics: this.generateStatistics(analysis),
    };

    return exportData;
  }

  // Генерация статистики
  generateStatistics(analysis) {
    const statistics = {
      totalPackets: analysis.summary.totalPackets,
      totalFlows: analysis.summary.totalFlows,
      totalProtocols: analysis.summary.totalProtocols,
      totalAnomalies: analysis.summary.totalAnomalies,
      protocols: analysis.protocols,
      topFlows: this.getTopFlows(analysis.flows, 10),
      anomalies: analysis.anomalies,
    };

    return statistics;
  }

  // Получение топ потоков
  getTopFlows(flows, limit) {
    return flows.sort((a, b) => b.totalBytes - a.totalBytes).slice(0, limit);
  }
}

Основные компоненты Network Traffic Analysis

1. Packet Capture

• PCAP Files — PCAP файлы
• Real-time Capture — захват в реальном времени
• Filtering — фильтрация
• Storage — хранение

2. Protocol Analysis

• TCP Analysis — анализ TCP
• UDP Analysis — анализ UDP
• HTTP Analysis — анализ HTTP
• DNS Analysis — анализ DNS

3. Anomaly Detection

• Statistical Analysis — статистический анализ
• Behavioral Analysis — поведенческий анализ
• Pattern Recognition — распознавание паттернов
• Machine Learning — машинное обучение

Best Practices

1. Data Collection

• Proper Filtering — правильная фильтрация
• Adequate Storage — достаточное хранение
• Retention Policies — политики хранения
• Privacy Protection — защита конфиденциальности

2. Analysis

• Systematic Approach — системный подход
• Tool Selection — выбор инструментов
• Skill Development — развитие навыков
• Documentation — документация

3. Response

• Incident Response — реагирование на инциденты
• Forensic Analysis — криминалистический анализ
• Evidence Preservation — сохранение доказательств
• Legal Compliance — правовое соответствие

Заключение

Network Traffic Analysis — это критически важная область кибербезопасности, которая требует:

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

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

---

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