Многофакторная аутентификация (MFA/2FA)

Что такое MFA?

Multi-Factor Authentication (MFA) — это метод аутентификации, который требует от пользователя предоставить два или более независимых фактора для подтверждения своей личности. Это значительно повышает безопасность по сравнению с использованием только пароля.

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

• Независимость факторов — факторы должны быть независимыми друг от друга
• Разнообразие типов — использование разных типов факторов
• Дополнительная защита — даже если один фактор скомпрометирован, другие остаются защищенными

Типы факторов аутентификации

1. Что-то, что вы знаете (Something You Know)

Знание секретной информации

Примеры:

• Пароли — текстовые пароли
• PIN-коды — числовые коды
• Секретные вопросы — ответы на личные вопросы
• Парольные фразы — длинные текстовые пароли

Примеры реализации:

// Система управления паролями для MFA
class PasswordManager {
  constructor() {
    this.passwordPolicy = {
      minLength: 12,
      requireUppercase: true,
      requireLowercase: true,
      requireNumbers: true,
      requireSpecialChars: true,
      maxAge: 90, // дни
      historyCount: 12,
    };
    this.passwordHistory = new Map();
  }

  // Генерация безопасного пароля
  generateSecurePassword(length = 16) {
    const charset = {
      uppercase: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
      lowercase: "abcdefghijklmnopqrstuvwxyz",
      numbers: "0123456789",
      special: "!@#$%^&*()_+-=[]{}|;:,.<>?",
    };

    let password = ";

    // Гарантируем наличие всех типов символов
    password += this.getRandomChar(charset.uppercase);
    password += this.getRandomChar(charset.lowercase);
    password += this.getRandomChar(charset.numbers);
    password += this.getRandomChar(charset.special);

    // Заполняем остальные символы
    const allChars = Object.values(charset).join(");
    for (let i = 4; i < length; i++) {
      password += this.getRandomChar(allChars);
    }

    // Перемешиваем символы
    return password
      .split(")
      .sort(() => Math.random() - 0.5)
      .join(");
  }

  // Получение случайного символа
  getRandomChar(charset) {
    return charset[Math.floor(Math.random() * charset.length)];
  }

  // Валидация пароля
  validatePassword(password, username) {
    const errors = [];

    // Проверка длины
    if (password.length < this.passwordPolicy.minLength) {
      errors.push(
        `Password must be at least ${this.passwordPolicy.minLength} characters long`
      );
    }

    // Проверка регистра
    if (this.passwordPolicy.requireUppercase && !/[A-Z]/.test(password)) {
      errors.push("Password must contain uppercase letters");
    }

    if (this.passwordPolicy.requireLowercase && !/[a-z]/.test(password)) {
      errors.push("Password must contain lowercase letters");
    }

    // Проверка цифр
    if (this.passwordPolicy.requireNumbers && !/\d/.test(password)) {
      errors.push("Password must contain numbers");
    }

    // Проверка специальных символов
    if (
      this.passwordPolicy.requireSpecialChars &&
      !/[!@#$%^&*()_+\-=\[\]{}|;:,.<>?]/.test(password)
    ) {
      errors.push("Password must contain special characters");
    }

    // Проверка на использование имени пользователя
    if (password.toLowerCase().includes(username.toLowerCase())) {
      errors.push("Password cannot contain username");
    }

    // Проверка истории паролей
    if (this.isPasswordInHistory(username, password)) {
      errors.push("Password cannot be reused from recent history");
    }

    return {
      valid: errors.length === 0,
      errors: errors,
    };
  }

  // Проверка истории паролей
  isPasswordInHistory(username, password) {
    if (!this.passwordHistory.has(username)) {
      return false;
    }

    const history = this.passwordHistory.get(username);
    return history.some((oldPassword) => oldPassword === password);
  }

  // Сохранение пароля в историю
  savePasswordToHistory(username, password) {
    if (!this.passwordHistory.has(username)) {
      this.passwordHistory.set(username, []);
    }

    const history = this.passwordHistory.get(username);
    history.push(password);

    // Ограничиваем количество паролей в истории
    if (history.length > this.passwordPolicy.historyCount) {
      history.shift();
    }
  }
}

2. Что-то, что у вас есть (Something You Have)

Физический объект или устройство

Примеры:

• SMS-коды — коды, отправляемые по SMS
• TOTP-токены — временные коды (Google Authenticator, Authy)
• Hardware токены — физические устройства (YubiKey)
• Push-уведомления — уведомления в мобильном приложении
• Email-коды — коды, отправляемые по email

Примеры реализации:

// Система TOTP для MFA
const crypto = require("crypto");

class TOTPGenerator {
  constructor() {
    this.algorithm = "sha1";
    this.digits = 6;
    this.period = 30; // секунды
  }

  // Генерация секретного ключа
  generateSecret() {
    return crypto.randomBytes(20).toString("base32");
  }

  // Генерация TOTP кода
  generateTOTP(secret, timestamp = Date.now()) {
    const time = Math.floor(timestamp / 1000 / this.period);
    const timeBuffer = Buffer.alloc(8);
    timeBuffer.writeUInt32BE(0, 0);
    timeBuffer.writeUInt32BE(time, 4);

    const key = this.base32Decode(secret);
    const hmac = crypto.createHmac(this.algorithm, key);
    hmac.update(timeBuffer);
    const hash = hmac.digest();

    const offset = hash[hash.length - 1] & 0xf;
    const code =
      ((hash[offset] & 0x7f) << 24) |
      ((hash[offset + 1] & 0xff) << 16) |
      ((hash[offset + 2] & 0xff) << 8) |
      (hash[offset + 3] & 0xff);

    return (code % Math.pow(10, this.digits))
      .toString()
      .padStart(this.digits, "0");
  }

  // Валидация TOTP кода
  validateTOTP(secret, code, window = 1) {
    const timestamp = Date.now();

    for (let i = -window; i <= window; i++) {
      const testTime = timestamp + i * this.period * 1000;
      const expectedCode = this.generateTOTP(secret, testTime);

      if (expectedCode === code) {
        return true;
      }
    }

    return false;
  }

  // Декодирование base32
  base32Decode(str) {
    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
    const padding = "=";

    let bits = 0;
    let value = 0;
    let index = 0;
    const result = [];

    for (let i = 0; i < str.length; i++) {
      const char = str[i].toUpperCase();

      if (char === padding) {
        break;
      }

      const charIndex = alphabet.indexOf(char);
      if (charIndex === -1) {
        throw new Error("Invalid base32 character");
      }

      value = (value << 5) | charIndex;
      bits += 5;

      if (bits >= 8) {
        result[index++] = (value >>> (bits - 8)) & 0xff;
        bits -= 8;
      }
    }

    return Buffer.from(result);
  }

  // Генерация QR-кода для настройки
  generateQRCodeData(user, secret, issuer = "MyApp") {
    const otpAuthUrl = `otpauth://totp/${user}?secret=${secret}&issuer=${issuer}`;
    return otpAuthUrl;
  }
}

// Система SMS для MFA
class SMSMFA {
  constructor(smsProvider) {
    this.smsProvider = smsProvider;
    this.codes = new Map();
    this.codeExpiry = 5 * 60 * 1000; // 5 минут
  }

  // Отправка SMS кода
  async sendSMSCode(phoneNumber) {
    const code = this.generateCode();
    const expiry = Date.now() + this.codeExpiry;

    // Сохраняем код
    this.codes.set(phoneNumber, {
      code: code,
      expiry: expiry,
      attempts: 0,
    });

    // Отправляем SMS
    try {
      await this.smsProvider.send(
        phoneNumber,
        `Your verification code is: ${code}`
      );
      return { success: true, message: "SMS sent successfully" };
    } catch (error) {
      this.codes.delete(phoneNumber);
      return { success: false, error: error.message };
    }
  }

  // Валидация SMS кода
  validateSMSCode(phoneNumber, code) {
    const stored = this.codes.get(phoneNumber);

    if (!stored) {
      return { valid: false, error: "No code found for this phone number" };
    }

    if (Date.now() > stored.expiry) {
      this.codes.delete(phoneNumber);
      return { valid: false, error: "Code has expired" };
    }

    if (stored.attempts >= 3) {
      this.codes.delete(phoneNumber);
      return { valid: false, error: "Too many attempts" };
    }

    if (stored.code !== code) {
      stored.attempts++;
      return { valid: false, error: "Invalid code" };
    }

    // Код валиден
    this.codes.delete(phoneNumber);
    return { valid: true };
  }

  // Генерация 6-значного кода
  generateCode() {
    return Math.floor(100000 + Math.random() * 900000).toString();
  }
}

3. Что-то, что вы есть (Something You Are)

Биометрические характеристики

Примеры:

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

Примеры реализации:

// Система биометрической аутентификации
class BiometricAuthentication {
  constructor() {
    this.biometricTemplates = new Map();
    this.threshold = 0.8; // Порог совпадения
  }

  // Регистрация биометрического шаблона
  registerBiometric(userId, biometricData, type) {
    const template = this.extractTemplate(biometricData, type);

    if (!this.biometricTemplates.has(userId)) {
      this.biometricTemplates.set(userId, new Map());
    }

    this.biometricTemplates.get(userId).set(type, template);

    return { success: true, message: "Biometric template registered" };
  }

  // Аутентификация по биометрии
  authenticateBiometric(userId, biometricData, type) {
    const userTemplates = this.biometricTemplates.get(userId);

    if (!userTemplates || !userTemplates.has(type)) {
      return { valid: false, error: "No biometric template found" };
    }

    const storedTemplate = userTemplates.get(type);
    const inputTemplate = this.extractTemplate(biometricData, type);

    const similarity = this.calculateSimilarity(storedTemplate, inputTemplate);

    return {
      valid: similarity >= this.threshold,
      similarity: similarity,
      threshold: this.threshold,
    };
  }

  // Извлечение шаблона из биометрических данных
  extractTemplate(biometricData, type) {
    switch (type) {
      case "fingerprint":
        return this.extractFingerprintTemplate(biometricData);
      case "face":
        return this.extractFaceTemplate(biometricData);
      case "voice":
        return this.extractVoiceTemplate(biometricData);
      default:
        throw new Error("Unsupported biometric type");
    }
  }

  // Извлечение шаблона отпечатка пальца
  extractFingerprintTemplate(fingerprintData) {
    // Упрощенная реализация - в реальной системе используется сложная обработка
    const features = {
      minutiae: this.extractMinutiae(fingerprintData),
      ridges: this.extractRidges(fingerprintData),
      valleys: this.extractValleys(fingerprintData),
    };

    return features;
  }

  // Извлечение шаблона лица
  extractFaceTemplate(faceData) {
    // Упрощенная реализация - в реальной системе используется машинное обучение
    const features = {
      landmarks: this.extractFacialLandmarks(faceData),
      texture: this.extractTextureFeatures(faceData),
      geometry: this.extractGeometryFeatures(faceData),
    };

    return features;
  }

  // Извлечение шаблона голоса
  extractVoiceTemplate(voiceData) {
    // Упрощенная реализация - в реальной системе используется спектральный анализ
    const features = {
      mfcc: this.extractMFCC(voiceData),
      pitch: this.extractPitch(voiceData),
      formants: this.extractFormants(voiceData),
    };

    return features;
  }

  // Расчет схожести шаблонов
  calculateSimilarity(template1, template2) {
    // Упрощенная реализация - в реальной системе используется сложный алгоритм
    let totalSimilarity = 0;
    let featureCount = 0;

    for (const [feature, value1] of Object.entries(template1)) {
      if (template2[feature]) {
        const similarity = this.calculateFeatureSimilarity(
          value1,
          template2[feature]
        );
        totalSimilarity += similarity;
        featureCount++;
      }
    }

    return featureCount > 0 ? totalSimilarity / featureCount : 0;
  }

  // Расчет схожести отдельных признаков
  calculateFeatureSimilarity(feature1, feature2) {
    // Упрощенная реализация
    if (Array.isArray(feature1) && Array.isArray(feature2)) {
      return this.calculateArraySimilarity(feature1, feature2);
    }

    if (typeof feature1 === "number" && typeof feature2 === "number") {
      return 1 - Math.abs(feature1 - feature2) / Math.max(feature1, feature2);
    }

    return feature1 === feature2 ? 1 : 0;
  }

  // Расчет схожести массивов
  calculateArraySimilarity(array1, array2) {
    if (array1.length !== array2.length) {
      return 0;
    }

    let similarity = 0;
    for (let i = 0; i < array1.length; i++) {
      similarity += this.calculateFeatureSimilarity(array1[i], array2[i]);
    }

    return similarity / array1.length;
  }

  // Заглушки для извлечения признаков
  extractMinutiae(data) {
    return [];
  }
  extractRidges(data) {
    return [];
  }
  extractValleys(data) {
    return [];
  }
  extractFacialLandmarks(data) {
    return [];
  }
  extractTextureFeatures(data) {
    return [];
  }
  extractGeometryFeatures(data) {
    return [];
  }
  extractMFCC(data) {
    return [];
  }
  extractPitch(data) {
    return 0;
  }
  extractFormants(data) {
    return [];
  }
}

Методы реализации MFA

1. Адаптивная аутентификация

Динамический выбор факторов на основе риска

Примеры реализации:

// Система адаптивной аутентификации
class AdaptiveAuthentication {
  constructor() {
    this.riskFactors = {
      location: 0.3,
      device: 0.2,
      time: 0.1,
      behavior: 0.2,
      network: 0.2,
    };
    this.riskThresholds = {
      low: 0.3,
      medium: 0.6,
      high: 0.8,
    };
  }

  // Оценка риска аутентификации
  assessRisk(user, context) {
    let totalRisk = 0;

    // Оценка риска по местоположению
    const locationRisk = this.assessLocationRisk(user, context.location);
    totalRisk += locationRisk * this.riskFactors.location;

    // Оценка риска по устройству
    const deviceRisk = this.assessDeviceRisk(user, context.device);
    totalRisk += deviceRisk * this.riskFactors.device;

    // Оценка риска по времени
    const timeRisk = this.assessTimeRisk(user, context.timestamp);
    totalRisk += timeRisk * this.riskFactors.time;

    // Оценка риска по поведению
    const behaviorRisk = this.assessBehaviorRisk(user, context.behavior);
    totalRisk += behaviorRisk * this.riskFactors.behavior;

    // Оценка риска по сети
    const networkRisk = this.assessNetworkRisk(user, context.network);
    totalRisk += networkRisk * this.riskFactors.network;

    return {
      totalRisk: totalRisk,
      factors: {
        location: locationRisk,
        device: deviceRisk,
        time: timeRisk,
        behavior: behaviorRisk,
        network: networkRisk,
      },
    };
  }

  // Определение требуемых факторов
  determineRequiredFactors(riskAssessment) {
    const risk = riskAssessment.totalRisk;

    if (risk < this.riskThresholds.low) {
      return ["password"]; // Только пароль
    } else if (risk < this.riskThresholds.medium) {
      return ["password", "totp"]; // Пароль + TOTP
    } else if (risk < this.riskThresholds.high) {
      return ["password", "totp", "sms"]; // Пароль + TOTP + SMS
    } else {
      return ["password", "totp", "sms", "biometric"]; // Все факторы
    }
  }

  // Оценка риска по местоположению
  assessLocationRisk(user, location) {
    if (!user.lastKnownLocation) {
      return 0.5; // Неизвестное местоположение
    }

    const distance = this.calculateDistance(user.lastKnownLocation, location);
    const timeDiff = Date.now() - user.lastLoginTime;

    // Если большое расстояние за короткое время - высокий риск
    if (distance > 1000 && timeDiff < 3600000) {
      // 1000км за час
      return 0.9;
    }

    // Если новое местоположение - средний риск
    if (distance > 100) {
      // 100км
      return 0.6;
    }

    return 0.1; // Низкий риск
  }

  // Оценка риска по устройству
  assessDeviceRisk(user, device) {
    if (!user.knownDevices.includes(device.fingerprint)) {
      return 0.8; // Неизвестное устройство
    }

    if (device.isCompromised) {
      return 0.9; // Скомпрометированное устройство
    }

    if (!device.isSecure) {
      return 0.6; // Небезопасное устройство
    }

    return 0.1; // Низкий риск
  }

  // Оценка риска по времени
  assessTimeRisk(user, timestamp) {
    const hour = new Date(timestamp).getHours();

    // Необычное время входа
    if (hour < 6 || hour > 22) {
      return 0.7;
    }

    // Выходные дни
    const dayOfWeek = new Date(timestamp).getDay();
    if (dayOfWeek === 0 || dayOfWeek === 6) {
      return 0.5;
    }

    return 0.1; // Низкий риск
  }

  // Оценка риска по поведению
  assessBehaviorRisk(user, behavior) {
    // Анализ скорости набора
    if (behavior.typingSpeed < user.normalTypingSpeed * 0.5) {
      return 0.8; // Медленный набор
    }

    // Анализ паттернов навигации
    if (behavior.navigationPattern !== user.normalPattern) {
      return 0.6; // Необычная навигация
    }

    return 0.1; // Низкий риск
  }

  // Оценка риска по сети
  assessNetworkRisk(user, network) {
    if (network.isPublic) {
      return 0.8; // Публичная сеть
    }

    if (network.isVPN) {
      return 0.4; // VPN
    }

    if (network.isCorporate) {
      return 0.1; // Корпоративная сеть
    }

    return 0.3; // Домашняя сеть
  }

  // Расчет расстояния между координатами
  calculateDistance(loc1, loc2) {
    const R = 6371; // Радиус Земли в км
    const dLat = this.toRadians(loc2.lat - loc1.lat);
    const dLon = this.toRadians(loc2.lon - loc1.lon);
    const a =
      Math.sin(dLat / 2) * Math.sin(dLat / 2) +
      Math.cos(this.toRadians(loc1.lat)) *
        Math.cos(this.toRadians(loc2.lat)) *
        Math.sin(dLon / 2) *
        Math.sin(dLon / 2);
    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
    return R * c;
  }

  // Преобразование в радианы
  toRadians(degrees) {
    return degrees * (Math.PI / 180);
  }
}

2. Push-уведомления

Уведомления в мобильном приложении

Примеры реализации:

// Система push-уведомлений для MFA
class PushNotificationMFA {
  constructor(pushService) {
    this.pushService = pushService;
    this.pendingRequests = new Map();
    this.requestTimeout = 300000; // 5 минут
  }

  // Отправка push-уведомления
  async sendPushNotification(userId, deviceToken, context) {
    const requestId = this.generateRequestId();
    const expiry = Date.now() + this.requestTimeout;

    // Сохраняем запрос
    this.pendingRequests.set(requestId, {
      userId: userId,
      deviceToken: deviceToken,
      context: context,
      expiry: expiry,
      status: "pending",
    });

    // Отправляем push-уведомление
    const notification = {
      title: "Authentication Request",
      body: `Login attempt from ${context.ip} at ${context.location}`,
      data: {
        requestId: requestId,
        action: "authenticate",
        context: context,
      },
    };

    try {
      await this.pushService.send(deviceToken, notification);
      return { success: true, requestId: requestId };
    } catch (error) {
      this.pendingRequests.delete(requestId);
      return { success: false, error: error.message };
    }
  }

  // Обработка ответа от пользователя
  async handleUserResponse(requestId, response) {
    const request = this.pendingRequests.get(requestId);

    if (!request) {
      return { valid: false, error: "Request not found" };
    }

    if (Date.now() > request.expiry) {
      this.pendingRequests.delete(requestId);
      return { valid: false, error: "Request expired" };
    }

    if (response.action === "approve") {
      request.status = "approved";
      this.pendingRequests.delete(requestId);
      return { valid: true, status: "approved" };
    } else if (response.action === "deny") {
      request.status = "denied";
      this.pendingRequests.delete(requestId);
      return { valid: true, status: "denied" };
    }

    return { valid: false, error: "Invalid response" };
  }

  // Генерация ID запроса
  generateRequestId() {
    return crypto.randomBytes(16).toString("hex");
  }

  // Очистка просроченных запросов
  cleanupExpiredRequests() {
    const now = Date.now();
    for (const [requestId, request] of this.pendingRequests) {
      if (now > request.expiry) {
        this.pendingRequests.delete(requestId);
      }
    }
  }
}

Best Practices для MFA

1. Выбор факторов

• Используйте разные типы факторов — не полагайтесь только на один тип
• Учитывайте удобство пользователей — баланс между безопасностью и удобством
• Планируйте резервные методы — на случай недоступности основного фактора

2. Безопасность

• Защищайте секретные ключи — используйте безопасное хранение
• Ограничивайте попытки — защита от брутфорса
• Логируйте события — для аудита и расследования
• Регулярно обновляйте — обновляйте алгоритмы и протоколы

3. Пользовательский опыт

• Объясняйте необходимость — пользователи должны понимать важность MFA
• Предоставляйте альтернативы — несколько способов аутентификации
• Обучайте пользователей — как правильно использовать MFA
• Тестируйте удобство — регулярно проверяйте UX

Заключение

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

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

Помните: MFA — это не просто технология, а стратегический подход к обеспечению безопасности. Успех зависит от правильного выбора факторов, качественной реализации и постоянного совершенствования.

---

Совет: Начните с простых факторов (SMS, TOTP), затем постепенно добавляйте более сложные (биометрия, hardware токены). Не забывайте о резервных методах аутентификации!