Risk Assessment Methods - Методы оценки рисков

Что такое оценка рисков?

Risk Assessment — это процесс идентификации, анализа и оценки рисков для информационных активов организации. Цель — определить приоритеты защиты и принять обоснованные решения по управлению рисками.

Ключевые принципы

• Идентификация — выявление всех возможных рисков
• Анализ — анализ вероятности и воздействия
• Оценка — определение уровня риска
• Приоритизация — ранжирование рисков
• Управление — принятие мер по снижению рисков

Типы оценки рисков

1. Качественная оценка (Qualitative)

Качественная оценка использует описательные шкалы для оценки рисков без точных числовых значений.

Преимущества

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

Недостатки

• Субъективность — зависимость от экспертов
• Неточность — отсутствие точных значений
• Сравнение — сложность сравнения рисков
• Воспроизводимость — сложность воспроизведения

2. Количественная оценка (Quantitative)

Количественная оценка использует числовые значения для измерения рисков.

Преимущества

• Точность — точные числовые значения
• Сравнение — легко сравнивать риски
• Анализ — статистический анализ
• Воспроизводимость — воспроизводимые результаты

Недостатки

• Сложность — требует больше данных
• Время — длительное выполнение
• Точность данных — требует точных данных
• Стоимость — высокая стоимость

Методы оценки рисков

1. FAIR (Factor Analysis of Information Risk)

FAIR — это методология для количественной оценки рисков информационной безопасности.

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

• Loss Event Frequency (LEF) — частота событий потерь
• Threat Event Frequency (TEF) — частота угроз
• Vulnerability — уязвимость
• Loss Magnitude (LM) — величина потерь

// Реализация FAIR модели
class FAIRRiskAssessment {
  constructor() {
    this.assets = new Map();
    this.threats = new Map();
    this.vulnerabilities = new Map();
    this.controls = new Map();
  }

  // Добавление актива
  addAsset(assetId, assetData) {
    const asset = {
      id: assetId,
      name: assetData.name,
      value: assetData.value,
      criticality: assetData.criticality,
      confidentiality: assetData.confidentiality,
      integrity: assetData.integrity,
      availability: assetData.availability,
    };

    this.assets.set(assetId, asset);

    return {
      success: true,
      asset: asset,
    };
  }

  // Добавление угрозы
  addThreat(threatId, threatData) {
    const threat = {
      id: threatId,
      name: threatData.name,
      type: threatData.type,
      frequency: threatData.frequency, // per year
      capability: threatData.capability, // 1-10 scale
      motivation: threatData.motivation, // 1-10 scale
      opportunity: threatData.opportunity, // 1-10 scale
    };

    this.threats.set(threatId, threat);

    return {
      success: true,
      threat: threat,
    };
  }

  // Добавление уязвимости
  addVulnerability(vulnId, vulnData) {
    const vulnerability = {
      id: vulnId,
      name: vulnData.name,
      severity: vulnData.severity, // 1-10 scale
      exploitability: vulnData.exploitability, // 1-10 scale
      impact: vulnData.impact, // 1-10 scale
      controls: vulnData.controls || [],
    };

    this.vulnerabilities.set(vulnId, vulnerability);

    return {
      success: true,
      vulnerability: vulnerability,
    };
  }

  // Расчет Threat Event Frequency (TEF)
  calculateTEF(threatId, assetId) {
    const threat = this.threats.get(threatId);
    const asset = this.assets.get(assetId);

    if (!threat || !asset) {
      return null;
    }

    // Базовая частота угрозы
    const baseFrequency = threat.frequency;

    // Модификаторы
    const capabilityModifier = threat.capability / 10;
    const motivationModifier = threat.motivation / 10;
    const opportunityModifier = threat.opportunity / 10;
    const assetValueModifier = asset.criticality / 10;

    // Расчет TEF
    const tef =
      baseFrequency *
      capabilityModifier *
      motivationModifier *
      opportunityModifier *
      assetValueModifier;

    return {
      tef: tef,
      baseFrequency: baseFrequency,
      modifiers: {
        capability: capabilityModifier,
        motivation: motivationModifier,
        opportunity: opportunityModifier,
        assetValue: assetValueModifier,
      },
    };
  }

  // Расчет Loss Event Frequency (LEF)
  calculateLEF(threatId, assetId, vulnId) {
    const tef = this.calculateTEF(threatId, assetId);
    const vulnerability = this.vulnerabilities.get(vulnId);

    if (!tef || !vulnerability) {
      return null;
    }

    // Уязвимость влияет на вероятность успешной атаки
    const vulnerabilityFactor = vulnerability.severity / 10;
    const exploitabilityFactor = vulnerability.exploitability / 10;

    // Эффективность контролей
    const controlEffectiveness = this.calculateControlEffectiveness(vulnId);

    // Расчет LEF
    const lef =
      tef.tef *
      vulnerabilityFactor *
      exploitabilityFactor *
      (1 - controlEffectiveness);

    return {
      lef: lef,
      tef: tef.tef,
      vulnerabilityFactor: vulnerabilityFactor,
      exploitabilityFactor: exploitabilityFactor,
      controlEffectiveness: controlEffectiveness,
    };
  }

  // Расчет Loss Magnitude (LM)
  calculateLM(assetId, threatId) {
    const asset = this.assets.get(assetId);
    const threat = this.threats.get(threatId);

    if (!asset || !threat) {
      return null;
    }

    // Базовое значение актива
    const baseValue = asset.value;

    // Модификаторы воздействия
    const confidentialityImpact = asset.confidentiality / 10;
    const integrityImpact = asset.integrity / 10;
    const availabilityImpact = asset.availability / 10;

    // Расчет LM
    const lm =
      (baseValue *
        (confidentialityImpact + integrityImpact + availabilityImpact)) /
      3;

    return {
      lm: lm,
      baseValue: baseValue,
      impacts: {
        confidentiality: confidentialityImpact,
        integrity: integrityImpact,
        availability: availabilityImpact,
      },
    };
  }

  // Расчет общего риска
  calculateRisk(threatId, assetId, vulnId) {
    const lef = this.calculateLEF(threatId, assetId, vulnId);
    const lm = this.calculateLM(assetId, threatId);

    if (!lef || !lm) {
      return null;
    }

    // Общий риск = LEF * LM
    const risk = lef.lef * lm.lm;

    // Уровень риска
    const riskLevel = this.getRiskLevel(risk);

    return {
      risk: risk,
      lef: lef,
      lm: lm,
      level: riskLevel,
      recommendation: this.getRiskRecommendation(riskLevel),
    };
  }

  // Определение уровня риска
  getRiskLevel(risk) {
    if (risk >= 1000000) return "CRITICAL";
    if (risk >= 100000) return "HIGH";
    if (risk >= 10000) return "MEDIUM";
    if (risk >= 1000) return "LOW";
    return "VERY_LOW";
  }

  // Рекомендации по риску
  getRiskRecommendation(level) {
    const recommendations = {
      CRITICAL: "Immediate action required. Implement all available controls.",
      HIGH: "High priority. Implement controls within 30 days.",
      MEDIUM: "Medium priority. Implement controls within 90 days.",
      LOW: "Low priority. Implement controls within 6 months.",
      VERY_LOW: "Monitor and review periodically.",
    };

    return recommendations[level] || "Review and assess.";
  }

  // Расчет эффективности контролей
  calculateControlEffectiveness(vulnId) {
    const vulnerability = this.vulnerabilities.get(vulnId);
    if (!vulnerability || !vulnerability.controls) {
      return 0;
    }

    let totalEffectiveness = 0;
    let controlCount = 0;

    for (const controlId of vulnerability.controls) {
      const control = this.controls.get(controlId);
      if (control) {
        totalEffectiveness += control.effectiveness;
        controlCount++;
      }
    }

    return controlCount > 0 ? totalEffectiveness / controlCount : 0;
  }

  // Добавление контроля
  addControl(controlId, controlData) {
    const control = {
      id: controlId,
      name: controlData.name,
      type: controlData.type,
      effectiveness: controlData.effectiveness, // 0-1 scale
      cost: controlData.cost,
      implementation: controlData.implementation,
    };

    this.controls.set(controlId, control);

    return {
      success: true,
      control: control,
    };
  }
}

2. OCTAVE (Operationally Critical Threat, Asset, and Vulnerability Evaluation)

OCTAVE — это методология для оценки рисков, фокусирующаяся на операционных рисках.

Основные этапы

1. Подготовка — планирование и подготовка
2. Идентификация активов — выявление критических активов
3. Анализ угроз — анализ угроз для активов
4. Оценка уязвимостей — оценка уязвимостей
5. Планирование — разработка планов защиты

// Реализация OCTAVE методологии
class OCTAVERiskAssessment {
  constructor() {
    this.assets = new Map();
    this.threats = new Map();
    this.vulnerabilities = new Map();
    this.scenarios = new Map();
  }

  // Этап 1: Идентификация активов
  identifyAssets() {
    const assets = [];

    // Критерии критичности
    const criteria = {
      businessImpact: "HIGH", // HIGH, MEDIUM, LOW
      confidentiality: "HIGH",
      integrity: "HIGH",
      availability: "HIGH",
      regulatory: true,
      financial: true,
    };

    // Анализ активов
    for (const [assetId, asset] of this.assets) {
      const criticality = this.assessAssetCriticality(asset, criteria);

      if (criticality.level === "CRITICAL" || criticality.level === "HIGH") {
        assets.push({
          id: assetId,
          name: asset.name,
          criticality: criticality,
          dependencies: this.identifyDependencies(assetId),
          stakeholders: this.identifyStakeholders(assetId),
        });
      }
    }

    return {
      success: true,
      criticalAssets: assets,
      totalAssets: this.assets.size,
    };
  }

  // Оценка критичности актива
  assessAssetCriticality(asset, criteria) {
    let score = 0;
    let factors = [];

    // Бизнес-воздействие
    if (asset.businessImpact === criteria.businessImpact) {
      score += 3;
      factors.push("High business impact");
    }

    // Конфиденциальность
    if (asset.confidentiality === criteria.confidentiality) {
      score += 2;
      factors.push("High confidentiality requirement");
    }

    // Целостность
    if (asset.integrity === criteria.integrity) {
      score += 2;
      factors.push("High integrity requirement");
    }

    // Доступность
    if (asset.availability === criteria.availability) {
      score += 2;
      factors.push("High availability requirement");
    }

    // Регулятивные требования
    if (asset.regulatory === criteria.regulatory) {
      score += 1;
      factors.push("Regulatory compliance required");
    }

    // Финансовое воздействие
    if (asset.financial === criteria.financial) {
      score += 1;
      factors.push("High financial impact");
    }

    // Определение уровня критичности
    let level;
    if (score >= 8) level = "CRITICAL";
    else if (score >= 6) level = "HIGH";
    else if (score >= 4) level = "MEDIUM";
    else level = "LOW";

    return {
      level: level,
      score: score,
      factors: factors,
    };
  }

  // Этап 2: Анализ угроз
  analyzeThreats(assetId) {
    const asset = this.assets.get(assetId);
    if (!asset) {
      return { success: false, error: "Asset not found" };
    }

    const threats = [];

    // Категории угроз
    const threatCategories = [
      "Malicious Insiders",
      "Malicious Outsiders",
      "Accidental Insiders",
      "System Failures",
      "Natural Disasters",
    ];

    for (const category of threatCategories) {
      const threatScenarios = this.generateThreatScenarios(assetId, category);
      threats.push(...threatScenarios);
    }

    // Приоритизация угроз
    const prioritizedThreats = this.prioritizeThreats(threats);

    return {
      success: true,
      threats: prioritizedThreats,
      totalThreats: threats.length,
    };
  }

  // Генерация сценариев угроз
  generateThreatScenarios(assetId, category) {
    const scenarios = [];

    // Базовые сценарии для каждой категории
    const baseScenarios = {
      "Malicious Insiders": [
        "Data theft by employee",
        "Sabotage by disgruntled employee",
        "Unauthorized access escalation",
      ],
      "Malicious Outsiders": [
        "External hacker attack",
        "Social engineering attack",
        "Malware infection",
      ],
      "Accidental Insiders": [
        "Accidental data deletion",
        "Configuration error",
        "Phishing victim",
      ],
      "System Failures": ["Hardware failure", "Software bug", "Network outage"],
      "Natural Disasters": ["Fire damage", "Flood damage", "Power outage"],
    };

    const categoryScenarios = baseScenarios[category] || [];

    for (const scenario of categoryScenarios) {
      const threatScenario = {
        id: this.generateScenarioId(),
        assetId: assetId,
        category: category,
        description: scenario,
        likelihood: this.assessLikelihood(assetId, category),
        impact: this.assessImpact(assetId, category),
        risk: this.calculateRiskScore(assetId, category),
      };

      scenarios.push(threatScenario);
    }

    return scenarios;
  }

  // Оценка вероятности
  assessLikelihood(assetId, category) {
    // Упрощенная оценка вероятности
    const likelihoodFactors = {
      "Malicious Insiders": 0.3,
      "Malicious Outsiders": 0.7,
      "Accidental Insiders": 0.8,
      "System Failures": 0.4,
      "Natural Disasters": 0.1,
    };

    return likelihoodFactors[category] || 0.5;
  }

  // Оценка воздействия
  assessImpact(assetId, category) {
    const asset = this.assets.get(assetId);
    if (!asset) return 0.5;

    // Базовое воздействие на основе критичности актива
    let impact = 0.5;

    if (asset.criticality === "CRITICAL") impact = 0.9;
    else if (asset.criticality === "HIGH") impact = 0.7;
    else if (asset.criticality === "MEDIUM") impact = 0.5;
    else impact = 0.3;

    return impact;
  }

  // Расчет оценки риска
  calculateRiskScore(assetId, category) {
    const likelihood = this.assessLikelihood(assetId, category);
    const impact = this.assessImpact(assetId, category);

    return likelihood * impact;
  }

  // Приоритизация угроз
  prioritizeThreats(threats) {
    return threats.sort((a, b) => b.risk - a.risk);
  }

  // Этап 3: Оценка уязвимостей
  assessVulnerabilities(assetId) {
    const asset = this.assets.get(assetId);
    if (!asset) {
      return { success: false, error: "Asset not found" };
    }

    const vulnerabilities = [];

    // Категории уязвимостей
    const vulnCategories = [
      "Technical",
      "Operational",
      "Physical",
      "Personnel",
    ];

    for (const category of vulnCategories) {
      const vulns = this.identifyVulnerabilities(assetId, category);
      vulnerabilities.push(...vulns);
    }

    // Приоритизация уязвимостей
    const prioritizedVulns = this.prioritizeVulnerabilities(vulnerabilities);

    return {
      success: true,
      vulnerabilities: prioritizedVulns,
      totalVulnerabilities: vulnerabilities.length,
    };
  }

  // Идентификация уязвимостей
  identifyVulnerabilities(assetId, category) {
    const vulnerabilities = [];

    // Базовые уязвимости для каждой категории
    const baseVulnerabilities = {
      Technical: [
        "Unpatched software",
        "Weak authentication",
        "Insecure configuration",
        "Missing encryption",
      ],
      Operational: [
        "Insufficient monitoring",
        "Lack of incident response",
        "Poor change management",
        "Inadequate backup",
      ],
      Physical: [
        "Unlocked server room",
        "No access control",
        "Poor environmental controls",
        "Inadequate fire suppression",
      ],
      Personnel: [
        "Lack of security training",
        "Insufficient background checks",
        "No security awareness",
        "Poor access management",
      ],
    };

    const categoryVulns = baseVulnerabilities[category] || [];

    for (const vuln of categoryVulns) {
      const vulnerability = {
        id: this.generateVulnId(),
        assetId: assetId,
        category: category,
        description: vuln,
        severity: this.assessSeverity(vuln),
        exploitability: this.assessExploitability(vuln),
        impact: this.assessVulnImpact(assetId, vuln),
      };

      vulnerabilities.push(vulnerability);
    }

    return vulnerabilities;
  }

  // Оценка серьезности уязвимости
  assessSeverity(vuln) {
    // Упрощенная оценка серьезности
    const severityMap = {
      "Unpatched software": 0.9,
      "Weak authentication": 0.8,
      "Insecure configuration": 0.7,
      "Missing encryption": 0.8,
      "Insufficient monitoring": 0.6,
      "Lack of incident response": 0.7,
      "Poor change management": 0.5,
      "Inadequate backup": 0.6,
      "Unlocked server room": 0.8,
      "No access control": 0.9,
      "Poor environmental controls": 0.4,
      "Inadequate fire suppression": 0.5,
      "Lack of security training": 0.6,
      "Insufficient background checks": 0.5,
      "No security awareness": 0.7,
      "Poor access management": 0.8,
    };

    return severityMap[vuln] || 0.5;
  }

  // Оценка эксплуатируемости
  assessExploitability(vuln) {
    // Упрощенная оценка эксплуатируемости
    const exploitabilityMap = {
      "Unpatched software": 0.9,
      "Weak authentication": 0.8,
      "Insecure configuration": 0.7,
      "Missing encryption": 0.6,
      "Insufficient monitoring": 0.5,
      "Lack of incident response": 0.4,
      "Poor change management": 0.3,
      "Inadequate backup": 0.4,
      "Unlocked server room": 0.9,
      "No access control": 0.8,
      "Poor environmental controls": 0.2,
      "Inadequate fire suppression": 0.1,
      "Lack of security training": 0.6,
      "Insufficient background checks": 0.3,
      "No security awareness": 0.7,
      "Poor access management": 0.8,
    };

    return exploitabilityMap[vuln] || 0.5;
  }

  // Оценка воздействия уязвимости
  assessVulnImpact(assetId, vuln) {
    const asset = this.assets.get(assetId);
    if (!asset) return 0.5;

    // Базовое воздействие на основе критичности актива
    let impact = 0.5;

    if (asset.criticality === "CRITICAL") impact = 0.9;
    else if (asset.criticality === "HIGH") impact = 0.7;
    else if (asset.criticality === "MEDIUM") impact = 0.5;
    else impact = 0.3;

    return impact;
  }

  // Приоритизация уязвимостей
  prioritizeVulnerabilities(vulnerabilities) {
    return vulnerabilities.sort((a, b) => {
      const scoreA = a.severity * a.exploitability * a.impact;
      const scoreB = b.severity * b.exploitability * b.impact;
      return scoreB - scoreA;
    });
  }

  // Генерация ID сценария
  generateScenarioId() {
    return "SCEN-" + Date.now() + "-" + Math.random().toString(36).substr(2, 4);
  }

  // Генерация ID уязвимости
  generateVulnId() {
    return "VULN-" + Date.now() + "-" + Math.random().toString(36).substr(2, 4);
  }
}

3. Матрица рисков

// Матрица рисков для качественной оценки
class RiskMatrix {
  constructor() {
    this.likelihood = ["VERY_LOW", "LOW", "MEDIUM", "HIGH", "VERY_HIGH"];
    this.impact = ["VERY_LOW", "LOW", "MEDIUM", "HIGH", "VERY_HIGH"];
    this.riskLevels = ["VERY_LOW", "LOW", "MEDIUM", "HIGH", "VERY_HIGH"];
  }

  // Расчет уровня риска
  calculateRiskLevel(likelihood, impact) {
    const likelihoodIndex = this.likelihood.indexOf(likelihood);
    const impactIndex = this.impact.indexOf(impact);

    if (likelihoodIndex === -1 || impactIndex === -1) {
      return "UNKNOWN";
    }

    // Матрица рисков 5x5
    const matrix = [
      ["VERY_LOW", "VERY_LOW", "LOW", "LOW", "MEDIUM"],
      ["VERY_LOW", "LOW", "LOW", "MEDIUM", "HIGH"],
      ["LOW", "LOW", "MEDIUM", "HIGH", "HIGH"],
      ["LOW", "MEDIUM", "HIGH", "HIGH", "VERY_HIGH"],
      ["MEDIUM", "HIGH", "HIGH", "VERY_HIGH", "VERY_HIGH"],
    ];

    return matrix[likelihoodIndex][impactIndex];
  }

  // Получение цвета риска
  getRiskColor(riskLevel) {
    const colors = {
      VERY_LOW: "#00FF00", // Зеленый
      LOW: "#FFFF00", // Желтый
      MEDIUM: "#FFA500", // Оранжевый
      HIGH: "#FF0000", // Красный
      VERY_HIGH: "#800080", // Фиолетовый
    };

    return colors[riskLevel] || "#808080";
  }

  // Получение рекомендаций
  getRecommendations(riskLevel) {
    const recommendations = {
      VERY_LOW: "Monitor and review periodically.",
      LOW: "Implement basic controls and monitor.",
      MEDIUM: "Implement controls within 90 days.",
      HIGH: "Implement controls within 30 days.",
      VERY_HIGH: "Immediate action required.",
    };

    return recommendations[riskLevel] || "Review and assess.";
  }
}

Процесс оценки рисков

1. Планирование

• Определение scope — область оценки
• Формирование команды — команда экспертов
• Выбор метода — метод оценки
• Планирование ресурсов — временные и финансовые ресурсы

2. Идентификация

• Идентификация активов — выявление всех активов
• Идентификация угроз — выявление угроз
• Идентификация уязвимостей — выявление уязвимостей
• Идентификация контролей — существующие контроли

3. Анализ

• Анализ вероятности — оценка вероятности
• Анализ воздействия — оценка воздействия
• Анализ рисков — расчет уровня риска
• Анализ контролей — оценка эффективности

4. Оценка

• Приоритизация рисков — ранжирование рисков
• Оценка остаточного риска — риск после контролей
• Принятие решений — выбор мер по снижению
• Планирование — разработка планов

Best Practices

1. Планирование

• Регулярность — регулярные оценки рисков
• Обновление — обновление при изменениях
• Документирование — полное документирование
• Коммуникация — общение с заинтересованными сторонами

2. Выполнение

• Экспертиза — привлечение экспертов
• Данные — использование качественных данных
• Методология — следование методологии
• Валидация — проверка результатов

3. Управление

• Мониторинг — непрерывный мониторинг
• Обновление — регулярное обновление
• Отчетность — регулярная отчетность
• Улучшение — постоянное улучшение

Заключение

Оценка рисков — это критически важный процесс для информационной безопасности, который требует:

• Правильной методологии — выбора подходящего метода
• Качественных данных — использования точных данных
• Экспертизы — привлечения экспертов
• Регулярности — регулярного выполнения

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

---

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