Трафик-анализ и деанонимизация

Определение

Трафик-анализ (Traffic Analysis) — это метод анализа сетевого трафика для извлечения информации о коммуникациях без расшифровки их содержимого. Трафик-анализ позволяет определить участников коммуникации, их поведение, маршруты передачи данных и другую метаинформацию.

Основные принципы трафик-анализа

1. Метаданные vs содержимое

• Содержимое — что передается (зашифровано)
• Метаданные — когда, сколько, кому передается (видно)

2. Пассивный анализ

• Наблюдение за трафиком без вмешательства
• Сбор статистики о времени, объеме, частоте
• Корреляция различных потоков данных

3. Активный анализ

• Внедрение тестового трафика
• Измерение задержек и характеристик сети
• Атаки на анонимные сети

Типы информации в трафик-анализе

1. Временные характеристики

// Анализ временных паттернов
// Время между пакетами
const packetTimes = [0.1, 0.3, 0.7, 1.2, 1.8, 2.5];
const intervals = [];

// Вычисление интервалов между пакетами
for (let i = 1; i < packetTimes.length; i++) {
  intervals.push(packetTimes[i] - packetTimes[i - 1]);
}

// Анализ распределения интервалов
const histogram = {};
intervals.forEach((interval) => {
  const bin = Math.floor(interval * 10) / 10; // Округление до 0.1
  histogram[bin] = (histogram[bin] || 0) + 1;
});

console.log("Распределение интервалов между пакетами:", histogram);
console.log(
  "Средний интервал:",
  intervals.reduce((a, b) => a + b, 0) / intervals.length
);

2. Объемные характеристики

• Размер пакетов — может указывать на тип приложения
• Объем трафика — корреляция с активностью пользователя
• Паттерны передачи — burst vs постоянный поток

3. Частотные характеристики

• Частота запросов — может выдать тип активности
• Периодичность — регулярные паттерны поведения
• Корреляция событий — связь между различными действиями

Методы деанонимизации Tor

1. Timing-атаки

Принцип работы:

// Упрощенная модель timing-атаки на Tor
class TorCircuit {
  constructor() {
    this.guard = "guard_node";
    this.middle = "middle_node";
    this.exit = "exit_node";
    this.latency = Math.random() * 0.4 + 0.1; // Задержка сети 0.1-0.5
  }

  async sendPacket(data) {
    const startTime = Date.now();
    // Симуляция передачи через цепочку Tor
    await new Promise((resolve) => setTimeout(resolve, this.latency * 1000));
    return (Date.now() - startTime) / 1000; // Возвращаем время в секундах
  }
}

// Атака: измерение времени отклика
async function timingAttack() {
  const circuit = new TorCircuit();
  const responseTimes = [];

  for (let i = 0; i < 100; i++) {
    const responseTime = await circuit.sendPacket("test_data");
    responseTimes.push(responseTime);
  }

  // Анализ паттернов времени отклика
  const avgTime =
    responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length;
  return avgTime;
}

Корреляционные атаки:

// Корреляция трафика на входе и выходе Tor
function correlateTraffic(inputTraffic, outputTraffic) {
  /**
   * Корреляция входного и выходного трафика
   * для определения связи между узлами
   */

  // Вычисление среднего значения
  const mean = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length;

  // Вычисление стандартного отклонения
  const std = (arr) => {
    const avg = mean(arr);
    const variance =
      arr.reduce((a, b) => a + Math.pow(b - avg, 2), 0) / arr.length;
    return Math.sqrt(variance);
  };

  // Нормализация трафика
  const inputMean = mean(inputTraffic);
  const inputStd = std(inputTraffic);
  const inputNorm = inputTraffic.map((x) => (x - inputMean) / inputStd);

  const outputMean = mean(outputTraffic);
  const outputStd = std(outputTraffic);
  const outputNorm = outputTraffic.map((x) => (x - outputMean) / outputStd);

  // Вычисление корреляции
  const correlation =
    inputNorm.reduce((sum, x, i) => sum + x * outputNorm[i], 0) /
    inputNorm.length;

  return correlation;
}

// Пример использования
const inputData = Array.from(
  { length: 1000 },
  () => 100 + (Math.random() - 0.5) * 40
); // Входной трафик
const outputData = inputData.map((x) => x + (Math.random() - 0.5) * 10); // Выходной трафик с шумом
const correlation = correlateTraffic(inputData, outputData);
console.log(`Корреляция: ${correlation}`);

2. Атаки на поток данных

Website Fingerprinting:

// Создание отпечатка веб-сайта по трафику
class WebsiteFingerprint {
  constructor() {
    this.packetSizes = [];
    this.timingPatterns = [];
    this.directionPatterns = [];
  }

  analyzeTraffic(packets) {
    // Анализ трафика для создания отпечатка
    for (const packet of packets) {
      this.packetSizes.push(packet.size);
      this.timingPatterns.push(packet.timestamp);
      this.directionPatterns.push(packet.direction);
    }
  }

  createFingerprint() {
    // Создание уникального отпечатка
    const fingerprint = {
      avgPacketSize: this.calculateMean(this.packetSizes),
      packetSizeVariance: this.calculateVariance(this.packetSizes),
      timingEntropy: this.calculateEntropy(this.timingPatterns),
      directionRatio: this.calculateDirectionRatio(),
    };
    return fingerprint;
  }

  calculateMean(data) {
    return data.reduce((a, b) => a + b, 0) / data.length;
  }

  calculateVariance(data) {
    const mean = this.calculateMean(data);
    const variance =
      data.reduce((sum, x) => sum + Math.pow(x - mean, 2), 0) / data.length;
    return variance;
  }

  calculateEntropy(data) {
    // Вычисление энтропии данных
    const counts = {};
    data.forEach((value) => {
      counts[value] = (counts[value] || 0) + 1;
    });

    const probabilities = Object.values(counts).map(
      (count) => count / data.length
    );
    const entropy = -probabilities.reduce(
      (sum, prob) => sum + prob * Math.log2(prob),
      0
    );
    return entropy;
  }

  calculateDirectionRatio() {
    const inbound = this.directionPatterns.filter(
      (dir) => dir === "inbound"
    ).length;
    const outbound = this.directionPatterns.filter(
      (dir) => dir === "outbound"
    ).length;
    return inbound / (inbound + outbound);
  }
}

3. Атаки на узлы Tor

Компрометация узлов:

# Мониторинг узлов Tor для сбора статистики
# Использование Tor Metrics для анализа узлов

# Получение списка узлов
curl -s "https://onionoo.torproject.org/summary" | jq '.relays[] | select(.country == "US")'

# Анализ пропускной способности узлов
curl -s "https://onionoo.torproject.org/details" | jq '.relays[] | {nickname, consensus_weight}'

Sybil-атаки:

// Симуляция Sybil-атаки на сеть Tor
class SybilAttack {
  constructor(maliciousNodesCount) {
    this.maliciousNodes = [];
    this.createMaliciousNodes(maliciousNodesCount);
  }

  createMaliciousNodes(count) {
    // Создание злонамеренных узлов
    for (let i = 0; i < count; i++) {
      const node = {
        id: `malicious_node_${i}`,
        type: "malicious",
        bandwidth: Math.floor(Math.random() * 900) + 100, // MB/s
        uptime: Math.floor(Math.random() * 101), // %
      };
      this.maliciousNodes.push(node);
    }
  }

  attemptCircuitCompromise(circuit) {
    // Попытка компрометации цепочки
    let maliciousInCircuit = 0;
    for (const node of circuit) {
      if (this.maliciousNodes.includes(node)) {
        maliciousInCircuit++;
      }
    }

    // Если в цепочке есть злонамеренные узлы
    if (maliciousInCircuit > 0) {
      return this.correlateTraffic(circuit);
    }

    return null;
  }
}

Методы деанонимизации VPN

1. DNS-утечки

// Проверка DNS-утечек
async function checkDnsLeak() {
  // Проверка утечек DNS
  try {
    // Получение DNS-серверов через dns.lookup
    const dns = require("dns");
    const dnsServers = await new Promise((resolve, reject) => {
      dns.lookup("google.com", (err, address) => {
        if (err) reject(err);
        else resolve([address]);
      });
    });

    // Проверка через внешний сервис
    const response = await fetch("https://dnsleaktest.com/api/v1/dnsleak");
    const externalDns = await response.json();

    // Сравнение DNS-серверов
    for (const dnsServer of dnsServers) {
      if (!externalDns.dns_servers.includes(dnsServer)) {
        console.log(`DNS утечка обнаружена: ${dnsServer}`);
        return true;
      }
    }

    return false;
  } catch (error) {
    console.error("Ошибка при проверке DNS-утечек:", error);
    return false;
  }
}

2. WebRTC-утечки

// Проверка WebRTC-утечек в браузере
function checkWebRTCLeak() {
  const pc = new RTCPeerConnection({
    iceServers: [{ urls: "stun:stun.l.google.com:19302" }],
  });

  pc.createDataChannel(");
  pc.createOffer().then((offer) => pc.setLocalDescription(offer));

  pc.onicecandidate = function (ice) {
    if (ice.candidate) {
      const candidate = ice.candidate.candidate;
      const ip = candidate.match(/([0-9]{1,3}(\.[0-9]{1,3}){3})/);
      if (ip) {
        console.log("WebRTC IP утечка:", ip[1]);
      }
    }
  };
}

3. Timing-атаки на VPN

// Timing-атака на VPN-соединение
class VPNTimingAttack {
  constructor(targetIp) {
    this.targetIp = targetIp;
    this.timingData = [];
  }

  async measurePingTimes(count = 100) {
    // Измерение времени пинга
    for (let i = 0; i < count; i++) {
      const startTime = Date.now();
      // Симуляция пинга
      const response = await this.pingHost(this.targetIp);
      const endTime = Date.now();

      if (response) {
        this.timingData.push((endTime - startTime) / 1000); // Время в секундах
      }

      await new Promise((resolve) => setTimeout(resolve, 100)); // Пауза между пингами
    }
  }

  analyzeTimingPatterns() {
    // Анализ паттернов времени отклика
    if (this.timingData.length === 0) {
      return null;
    }

    const mean =
      this.timingData.reduce((a, b) => a + b, 0) / this.timingData.length;
    const sorted = [...this.timingData].sort((a, b) => a - b);
    const median = sorted[Math.floor(sorted.length / 2)];

    const variance =
      this.timingData.reduce((sum, x) => sum + Math.pow(x - mean, 2), 0) /
      this.timingData.length;
    const stdDev = Math.sqrt(variance);

    const analysis = {
      mean: mean,
      median: median,
      stdDev: stdDev,
      min: Math.min(...this.timingData),
      max: Math.max(...this.timingData),
    };

    return analysis;
  }

  detectVpnCharacteristics() {
    // Определение характеристик VPN
    const analysis = this.analyzeTimingPatterns();

    if (!analysis) return "Недостаточно данных";

    // VPN обычно имеет более высокую задержку
    if (analysis.mean > 0.1) {
      // > 100ms
      return "Возможно VPN";
    } else {
      return "Прямое соединение";
    }
  }
}

Защита от трафик-анализа

1. Защита Tor

Padding и шум:

// Добавление шума для защиты от анализа
class TrafficPadding {
  constructor() {
    this.paddingEnabled = true;
    this.noiseLevel = 0.3; // 30% шума
  }

  async addPadding(originalTraffic) {
    // Добавление padding к трафику
    if (!this.paddingEnabled) {
      return originalTraffic;
    }

    const paddedTraffic = [];
    for (const packet of originalTraffic) {
      // Добавление случайной задержки
      const delay = Math.random() * this.noiseLevel;
      await new Promise((resolve) => setTimeout(resolve, delay * 1000));

      // Добавление случайных пакетов
      if (Math.random() < 0.1) {
        // 10% случайных пакетов
        const noisePacket = this.generateNoisePacket();
        paddedTraffic.push(noisePacket);
      }

      paddedTraffic.push(packet);
    }

    return paddedTraffic;
  }

  generateNoisePacket() {
    // Генерация шумового пакета
    return {
      size: Math.floor(Math.random() * 1436) + 64, // 64-1500
      timestamp: Date.now() / 1000,
      direction: Math.random() < 0.5 ? "inbound" : "outbound",
      content: this.generateRandomBytes(Math.floor(Math.random() * 480) + 32), // 32-512
    };
  }

  generateRandomBytes(length) {
    const bytes = new Uint8Array(length);
    for (let i = 0; i < length; i++) {
      bytes[i] = Math.floor(Math.random() * 256);
    }
    return bytes;
  }
}

Перемешивание трафика:

// Перемешивание пакетов для защиты от корреляции
class TrafficMixer {
  constructor(bufferSize = 100) {
    this.buffer = [];
    this.bufferSize = bufferSize;
    this.mixDelay = 0.5; // Задержка перемешивания
  }

  mixPackets(packets) {
    // Перемешивание пакетов
    // Добавление пакетов в буфер
    for (const packet of packets) {
      this.buffer.push(packet);
      // Ограничение размера буфера
      if (this.buffer.length > this.bufferSize) {
        this.buffer.shift();
      }
    }

    // Перемешивание буфера (Fisher-Yates shuffle)
    const mixedBuffer = [...this.buffer];
    for (let i = mixedBuffer.length - 1; i > 0; i--) {
      const j = Math.floor(Math.random() * (i + 1));
      [mixedBuffer[i], mixedBuffer[j]] = [mixedBuffer[j], mixedBuffer[i]];
    }

    // Возврат перемешанных пакетов
    return mixedBuffer;
  }
}

2. Защита VPN

Kill Switch:

// Kill Switch для VPN
const { exec } = require("child_process");

class VPNKillSwitch {
  constructor() {
    this.vpnActive = false;
    this.backupDns = ["8.8.8.8", "1.1.1.1"];
  }

  async checkVpnStatus() {
    // Проверка статуса VPN
    try {
      // Проверка IP-адреса
      const result = await new Promise((resolve, reject) => {
        exec("curl -s https://ipinfo.io/ip", (error, stdout, stderr) => {
          if (error) reject(error);
          else resolve(stdout);
        });
      });

      const currentIp = result.trim();

      // Сравнение с известным IP VPN
      const vpnIp = "VPN_SERVER_IP";
      this.vpnActive = currentIp === vpnIp;

      return this.vpnActive;
    } catch (error) {
      return false;
    }
  }

  async activateKillSwitch() {
    // Активация Kill Switch
    if (!(await this.checkVpnStatus())) {
      // Блокировка интернет-соединения
      exec("iptables -A OUTPUT -j DROP", (error, stdout, stderr) => {
        if (error) {
          console.error("Ошибка при активации Kill Switch:", error);
        } else {
          console.log("Kill Switch активирован - интернет заблокирован");
        }
      });
    }
  }
}

DNS-защита:

// Защита от DNS-утечек
const fs = require("fs");
const { exec } = require("child_process");

class DNSProtection {
  constructor() {
    this.vpnDns = ["10.0.0.1"]; // DNS VPN-сервера
    this.blockedDns = ["8.8.8.8", "1.1.1.1"]; // Блокируемые DNS
  }

  configureDns() {
    // Настройка DNS для VPN
    // Установка DNS VPN-сервера
    const dnsConfig = this.vpnDns.map((dns) => `nameserver ${dns}`).join("\n");
    fs.writeFileSync("/etc/resolv.conf", dnsConfig);
  }

  blockExternalDns() {
    // Блокировка внешних DNS-серверов
    for (const dns of this.blockedDns) {
      exec(
        `iptables -A OUTPUT -d ${dns} -p udp --dport 53 -j DROP`,
        (error, stdout, stderr) => {
          if (error) {
            console.error(`Ошибка при блокировке DNS ${dns}:`, error);
          }
        }
      );
    }
  }
}

Современные техники атак

1. Machine Learning атаки

// Использование ML для деанонимизации
// Простая реализация Random Forest на JavaScript
class MLTrafficAnalysis {
  constructor() {
    this.model = null;
    this.features = [];
    this.labels = [];
  }

  extractFeatures(trafficData) {
    // Извлечение признаков из трафика
    const features = [];
    for (const packet of trafficData) {
      const featureVector = [
        packet.size,
        packet.interArrivalTime,
        packet.direction === "inbound" ? 1 : 0, // Конвертация в числовое значение
        packet.protocol,
        packet.port,
      ];
      features.push(featureVector);
    }

    return features;
  }

  trainModel(trafficData, labels) {
    // Обучение модели (упрощенная версия)
    const features = this.extractFeatures(trafficData);

    // Простая реализация классификатора
    this.model = {
      features: features,
      labels: labels,
      // Простая логика классификации на основе средних значений
      predict: (newFeatures) => {
        const predictions = [];
        for (const featureVector of newFeatures) {
          // Простая эвристика для демонстрации
          const avgSize = featureVector[0];
          const direction = featureVector[2];

          if (avgSize > 1000 && direction === 1) {
            predictions.push("high_traffic_inbound");
          } else if (avgSize < 500) {
            predictions.push("low_traffic");
          } else {
            predictions.push("normal_traffic");
          }
        }
        return predictions;
      },
    };
  }

  predictWebsite(trafficData) {
    // Предсказание посещаемого сайта
    const features = this.extractFeatures(trafficData);
    return this.model.predict(features);
  }
}

2. Side-channel атаки

// Side-channel атака через анализ энергопотребления
const os = require("os");

class PowerAnalysisAttack {
  constructor() {
    this.powerSamples = [];
    this.trafficSamples = [];
  }

  async monitorPowerConsumption(duration = 60) {
    // Мониторинг энергопотребления
    const startTime = Date.now();

    while (Date.now() - startTime < duration * 1000) {
      // Измерение энергопотребления CPU
      const cpuPercent = this.getCpuPercent();

      // Измерение сетевого трафика
      const netIo = this.getNetworkIo();

      this.powerSamples.push(cpuPercent);
      this.trafficSamples.push(netIo.bytesSent + netIo.bytesRecv);

      await new Promise((resolve) => setTimeout(resolve, 100));
    }
  }

  getCpuPercent() {
    // Упрощенное измерение загрузки CPU
    const cpus = os.cpus();
    let totalIdle = 0;
    let totalTick = 0;

    for (const cpu of cpus) {
      for (const type in cpu.times) {
        totalTick += cpu.times[type];
      }
      totalIdle += cpu.times.idle;
    }

    return 100 - Math.round((100 * totalIdle) / totalTick);
  }

  getNetworkIo() {
    // Упрощенное измерение сетевого трафика
    const networkInterfaces = os.networkInterfaces();
    let bytesSent = 0;
    let bytesRecv = 0;

    for (const interface in networkInterfaces) {
      const iface = networkInterfaces[interface];
      for (const alias of iface) {
        if (alias.family === "IPv4" && !alias.internal) {
          // В реальной реализации здесь был бы доступ к статистике
          bytesSent += Math.floor(Math.random() * 1000);
          bytesRecv += Math.floor(Math.random() * 1000);
        }
      }
    }

    return { bytesSent, bytesRecv };
  }

  correlatePowerTraffic() {
    // Корреляция энергопотребления и трафика
    const correlation = this.calculateCorrelation(
      this.powerSamples,
      this.trafficSamples
    );
    return correlation;
  }

  calculateCorrelation(x, y) {
    const n = x.length;
    const sumX = x.reduce((a, b) => a + b, 0);
    const sumY = y.reduce((a, b) => a + b, 0);
    const sumXY = x.reduce((sum, xi, i) => sum + xi * y[i], 0);
    const sumX2 = x.reduce((sum, xi) => sum + xi * xi, 0);
    const sumY2 = y.reduce((sum, yi) => sum + yi * yi, 0);

    const numerator = n * sumXY - sumX * sumY;
    const denominator = Math.sqrt(
      (n * sumX2 - sumX * sumX) * (n * sumY2 - sumY * sumY)
    );

    return denominator === 0 ? 0 : numerator / denominator;
  }
}

Практические рекомендации

1. Для пользователей Tor

• Использование HTTPS везде, где возможно
• Отключение JavaScript в браузере
• Использование Tor Browser вместо обычных браузеров
• Избегание загрузки файлов через Tor

2. Для пользователей VPN

• Проверка DNS-утечек перед использованием
• Использование Kill Switch
• Выбор VPN-провайдеров с no-logs политикой
• Регулярная проверка IP-адреса

3. Для разработчиков

• Реализация padding в приложениях
• Использование постоянных соединений
• Минимизация метаданных в трафике
• Реализация защиты от timing-атак

Заключение

Трафик-анализ представляет серьезную угрозу для анонимности и приватности пользователей:

Основные угрозы:

• Деанонимизация пользователей Tor и VPN
• Анализ поведения и активности
• Корреляция различных потоков данных
• Использование машинного обучения для атак

Методы защиты:

• Добавление шума и padding к трафику
• Перемешивание пакетов
• Использование постоянных соединений
• Регулярная проверка на утечки

Понимание принципов трафик-анализа критически важно для специалистов по безопасности, разработчиков анонимных систем и пользователей, заботящихся о своей приватности в интернете.