PAM - Privileged Access Management

Что такое PAM?

PAM (Privileged Access Management) — это система управления привилегированными доступами, которая обеспечивает безопасность административных аккаунтов, мониторинг привилегий и контроль доступа к критически важным системам. PAM является критически важным компонентом корпоративной безопасности.

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

• Privileged Account Security — безопасность привилегированных аккаунтов
• Access Monitoring — мониторинг доступа
• Session Recording — запись сессий
• Just-in-Time Access — доступ по требованию
• Audit and Compliance — аудит и соответствие

Архитектура PAM

1. Privileged Account Management

// Система управления привилегированными аккаунтами
class PrivilegedAccountManagement {
  constructor() {
    this.privilegedAccounts = new Map();
    this.privilegedSessions = new Map();
    this.accessRequests = new Map();
    this.auditLog = [];
    this.policies = new Map();
  }

  // Создание привилегированного аккаунта
  createPrivilegedAccount(accountData) {
    const account = {
      id: this.generateAccountId(),
      username: accountData.username,
      accountType: accountData.accountType, // ADMIN, ROOT, SERVICE, EMERGENCY
      system: accountData.system,
      description: accountData.description,
      status: "ACTIVE",
      password: this.generateSecurePassword(),
      passwordExpiry: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000), // 90 дней
      lastPasswordChange: new Date(),
      lastUsed: null,
      createdBy: accountData.createdBy,
      createdAt: new Date(),
      updatedAt: new Date(),
    };

    // Валидация данных аккаунта
    const validation = this.validateAccountData(account);
    if (!validation.isValid) {
      throw new Error(
        `Account validation failed: ${validation.errors.join(", ")}`
      );
    }

    // Сохранение аккаунта
    this.privilegedAccounts.set(account.id, account);

    // Логирование
    this.logAuditEvent("PRIVILEGED_ACCOUNT_CREATED", accountData.createdBy, {
      accountId: account.id,
      username: account.username,
      accountType: account.accountType,
      system: account.system,
    });

    return account;
  }

  // Валидация данных аккаунта
  validateAccountData(account) {
    const errors = [];

    if (!account.username || account.username.trim() === ") {
      errors.push("Username is required");
    }

    if (
      !account.accountType ||
      !["ADMIN", "ROOT", "SERVICE", "EMERGENCY"].includes(account.accountType)
    ) {
      errors.push("Invalid account type");
    }

    if (!account.system || account.system.trim() === ") {
      errors.push("System is required");
    }

    if (!account.createdBy || account.createdBy.trim() === ") {
      errors.push("Created by is required");
    }

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

  // Запрос доступа к привилегированному аккаунту
  requestPrivilegedAccess(requestData) {
    const request = {
      id: this.generateRequestId(),
      userId: requestData.userId,
      accountId: requestData.accountId,
      reason: requestData.reason,
      duration: requestData.duration || 60, // минуты
      requestedAt: new Date(),
      status: "PENDING",
      approver: null,
      approvedAt: null,
      expiresAt: null,
      sessionId: null,
    };

    // Валидация запроса
    const validation = this.validateAccessRequest(request);
    if (!validation.isValid) {
      throw new Error(
        `Access request validation failed: ${validation.errors.join(", ")}`
      );
    }

    // Сохранение запроса
    this.accessRequests.set(request.id, request);

    // Логирование
    this.logAuditEvent("PRIVILEGED_ACCESS_REQUESTED", requestData.userId, {
      requestId: request.id,
      accountId: requestData.accountId,
      reason: requestData.reason,
      duration: requestData.duration,
    });

    return request;
  }

  // Валидация запроса доступа
  validateAccessRequest(request) {
    const errors = [];

    if (!request.userId || request.userId.trim() === ") {
      errors.push("User ID is required");
    }

    if (!request.accountId || request.accountId.trim() === ") {
      errors.push("Account ID is required");
    }

    if (!request.reason || request.reason.trim() === ") {
      errors.push("Reason is required");
    }

    if (request.duration <= 0 || request.duration > 480) {
      // максимум 8 часов
      errors.push("Invalid duration");
    }

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

  // Одобрение запроса доступа
  approveAccessRequest(requestId, approverId, approvalData) {
    const request = this.accessRequests.get(requestId);
    if (!request) {
      throw new Error("Access request not found");
    }

    if (request.status !== "PENDING") {
      throw new Error("Request is not pending");
    }

    // Обновление статуса запроса
    request.status = "APPROVED";
    request.approver = approverId;
    request.approvedAt = new Date();
    request.expiresAt = new Date(Date.now() + request.duration * 60 * 1000);

    // Создание привилегированной сессии
    const session = this.createPrivilegedSession(request);
    request.sessionId = session.id;

    // Логирование
    this.logAuditEvent("PRIVILEGED_ACCESS_APPROVED", request.userId, {
      requestId: requestId,
      approver: approverId,
      sessionId: session.id,
      duration: request.duration,
    });

    return {
      request: request,
      session: session,
    };
  }

  // Создание привилегированной сессии
  createPrivilegedSession(request) {
    const account = this.privilegedAccounts.get(request.accountId);
    if (!account) {
      throw new Error("Privileged account not found");
    }

    const session = {
      id: this.generateSessionId(),
      userId: request.userId,
      accountId: request.accountId,
      username: account.username,
      system: account.system,
      startedAt: new Date(),
      expiresAt: request.expiresAt,
      status: "ACTIVE",
      ipAddress: request.ipAddress,
      userAgent: request.userAgent,
      recordingId: null,
    };

    // Начало записи сессии
    if (this.shouldRecordSession(account)) {
      session.recordingId = this.startSessionRecording(session);
    }

    // Сохранение сессии
    this.privilegedSessions.set(session.id, session);

    // Обновление последнего использования аккаунта
    account.lastUsed = new Date();

    return session;
  }

  // Проверка необходимости записи сессии
  shouldRecordSession(account) {
    const recordableTypes = ["ADMIN", "ROOT", "EMERGENCY"];
    return recordableTypes.includes(account.accountType);
  }

  // Начало записи сессии
  startSessionRecording(session) {
    const recording = {
      id: this.generateRecordingId(),
      sessionId: session.id,
      startedAt: new Date(),
      status: "RECORDING",
      filePath: this.generateRecordingPath(session),
      size: 0,
    };

    // Сохранение записи
    this.sessionRecordings.set(recording.id, recording);

    return recording.id;
  }

  // Завершение привилегированной сессии
  endPrivilegedSession(sessionId, reason) {
    const session = this.privilegedSessions.get(sessionId);
    if (!session) {
      throw new Error("Session not found");
    }

    if (session.status !== "ACTIVE") {
      throw new Error("Session is not active");
    }

    // Обновление статуса сессии
    session.status = "ENDED";
    session.endedAt = new Date();
    session.endReason = reason;

    // Остановка записи сессии
    if (session.recordingId) {
      this.stopSessionRecording(session.recordingId);
    }

    // Логирование
    this.logAuditEvent("PRIVILEGED_SESSION_ENDED", session.userId, {
      sessionId: sessionId,
      reason: reason,
      duration: session.endedAt - session.startedAt,
    });

    return session;
  }

  // Остановка записи сессии
  stopSessionRecording(recordingId) {
    const recording = this.sessionRecordings.get(recordingId);
    if (!recording) {
      throw new Error("Recording not found");
    }

    recording.status = "COMPLETED";
    recording.endedAt = new Date();
    recording.duration = recording.endedAt - recording.startedAt;

    return recording;
  }

  // Проверка доступа к привилегированному аккаунту
  checkPrivilegedAccess(userId, accountId) {
    const activeSessions = Array.from(this.privilegedSessions.values()).filter(
      (session) =>
        session.userId === userId &&
        session.accountId === accountId &&
        session.status === "ACTIVE" &&
        session.expiresAt > new Date()
    );

    if (activeSessions.length > 0) {
      return {
        granted: true,
        session: activeSessions[0],
        reason: "Active privileged session found",
      };
    }

    return {
      granted: false,
      reason: "No active privileged session found",
    };
  }

  // Ротация паролей привилегированных аккаунтов
  rotatePrivilegedPassword(accountId, newPassword) {
    const account = this.privilegedAccounts.get(accountId);
    if (!account) {
      throw new Error("Account not found");
    }

    const oldPassword = account.password;
    account.password = newPassword;
    account.lastPasswordChange = new Date();
    account.passwordExpiry = new Date(Date.now() + 90 * 24 * 60 * 60 * 1000); // 90 дней

    // Логирование
    this.logAuditEvent("PRIVILEGED_PASSWORD_ROTATED", "SYSTEM", {
      accountId: accountId,
      username: account.username,
      system: account.system,
    });

    return account;
  }

  // Автоматическая ротация паролей
  autoRotatePasswords() {
    const now = new Date();
    const accountsToRotate = Array.from(
      this.privilegedAccounts.values()
    ).filter(
      (account) => account.status === "ACTIVE" && account.passwordExpiry <= now
    );

    const rotatedAccounts = [];

    for (const account of accountsToRotate) {
      try {
        const newPassword = this.generateSecurePassword();
        this.rotatePrivilegedPassword(account.id, newPassword);
        rotatedAccounts.push(account);
      } catch (error) {
        console.error(
          `Failed to rotate password for account ${account.id}:`,
          error
        );
      }
    }

    return rotatedAccounts;
  }

  // Генерация безопасного пароля
  generateSecurePassword() {
    const length = 16;
    const charset =
      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*";
    let password = ";

    for (let i = 0; i < length; i++) {
      password += charset.charAt(Math.floor(Math.random() * charset.length));
    }

    return password;
  }

  // Генерация ID аккаунта
  generateAccountId() {
    return (
      "pam_acc_" + Date.now() + "_" + Math.random().toString(36).substr(2, 8)
    );
  }

  // Генерация ID запроса
  generateRequestId() {
    return (
      "pam_req_" + Date.now() + "_" + Math.random().toString(36).substr(2, 8)
    );
  }

  // Генерация ID сессии
  generateSessionId() {
    return (
      "pam_sess_" + Date.now() + "_" + Math.random().toString(36).substr(2, 8)
    );
  }

  // Генерация ID записи
  generateRecordingId() {
    return (
      "pam_rec_" + Date.now() + "_" + Math.random().toString(36).substr(2, 8)
    );
  }

  // Логирование аудита
  logAuditEvent(eventType, userId, details) {
    const auditEvent = {
      id: this.generateAuditId(),
      eventType: eventType,
      userId: userId,
      details: details,
      timestamp: new Date(),
      ipAddress: details.ipAddress || "unknown",
      userAgent: details.userAgent || "unknown",
    };

    this.auditLog.push(auditEvent);

    // Ограничение размера лога
    if (this.auditLog.length > 50000) {
      this.auditLog = this.auditLog.slice(-25000);
    }
  }
}

2. Session Monitoring

// Система мониторинга сессий
class SessionMonitoring {
  constructor() {
    this.activeSessions = new Map();
    this.sessionEvents = new Map();
    this.alerts = new Map();
    this.monitoringRules = new Map();
  }

  // Мониторинг активной сессии
  monitorSession(sessionId) {
    const session = this.activeSessions.get(sessionId);
    if (!session) {
      throw new Error("Session not found");
    }

    const monitoring = {
      id: this.generateMonitoringId(),
      sessionId: sessionId,
      startedAt: new Date(),
      status: "MONITORING",
      events: [],
      alerts: [],
      lastActivity: new Date(),
    };

    // Сохранение мониторинга
    this.activeSessions.set(sessionId, { ...session, monitoring: monitoring });

    // Запуск мониторинга
    this.startSessionMonitoring(monitoring);

    return monitoring;
  }

  // Запуск мониторинга сессии
  startSessionMonitoring(monitoring) {
    const interval = setInterval(() => {
      this.checkSessionActivity(monitoring);
    }, 5000); // проверка каждые 5 секунд

    monitoring.intervalId = interval;
  }

  // Проверка активности сессии
  checkSessionActivity(monitoring) {
    const session = this.activeSessions.get(monitoring.sessionId);
    if (!session) {
      this.stopSessionMonitoring(monitoring);
      return;
    }

    // Проверка на истечение времени
    if (session.expiresAt <= new Date()) {
      this.handleSessionExpiry(monitoring);
      return;
    }

    // Проверка на неактивность
    const inactivityThreshold = 30 * 60 * 1000; // 30 минут
    if (Date.now() - monitoring.lastActivity.getTime() > inactivityThreshold) {
      this.handleSessionInactivity(monitoring);
      return;
    }

    // Проверка на подозрительную активность
    this.checkSuspiciousActivity(monitoring);
  }

  // Обработка истечения сессии
  handleSessionExpiry(monitoring) {
    const session = this.activeSessions.get(monitoring.sessionId);
    if (session) {
      session.status = "EXPIRED";
      session.endedAt = new Date();
    }

    this.stopSessionMonitoring(monitoring);

    // Логирование
    this.logSessionEvent(monitoring.sessionId, "SESSION_EXPIRED", {
      reason: "Session expired",
      duration: Date.now() - monitoring.startedAt.getTime(),
    });
  }

  // Обработка неактивности сессии
  handleSessionInactivity(monitoring) {
    const session = this.activeSessions.get(monitoring.sessionId);
    if (session) {
      session.status = "INACTIVE";
      session.endedAt = new Date();
    }

    this.stopSessionMonitoring(monitoring);

    // Логирование
    this.logSessionEvent(monitoring.sessionId, "SESSION_INACTIVE", {
      reason: "Session inactive",
      duration: Date.now() - monitoring.startedAt.getTime(),
    });
  }

  // Проверка подозрительной активности
  checkSuspiciousActivity(monitoring) {
    const session = this.activeSessions.get(monitoring.sessionId);
    if (!session) return;

    // Проверка на множественные неудачные попытки входа
    const failedAttempts = this.getFailedLoginAttempts(session);
    if (failedAttempts > 3) {
      this.triggerAlert(monitoring, "MULTIPLE_FAILED_LOGINS", {
        count: failedAttempts,
        threshold: 3,
      });
    }

    // Проверка на выполнение опасных команд
    const dangerousCommands = this.getDangerousCommands(session);
    if (dangerousCommands.length > 0) {
      this.triggerAlert(monitoring, "DANGEROUS_COMMANDS", {
        commands: dangerousCommands,
      });
    }

    // Проверка на доступ к чувствительным файлам
    const sensitiveFiles = this.getSensitiveFileAccess(session);
    if (sensitiveFiles.length > 0) {
      this.triggerAlert(monitoring, "SENSITIVE_FILE_ACCESS", {
        files: sensitiveFiles,
      });
    }
  }

  // Получение неудачных попыток входа
  getFailedLoginAttempts(session) {
    const events = this.sessionEvents.get(session.id) || [];
    return events.filter(
      (event) =>
        event.type === "LOGIN_FAILED" &&
        event.timestamp > new Date(Date.now() - 15 * 60 * 1000) // последние 15 минут
    ).length;
  }

  // Получение опасных команд
  getDangerousCommands(session) {
    const events = this.sessionEvents.get(session.id) || [];
    const dangerousPatterns = [
      /rm\s+-rf\s+\//,
      /chmod\s+777/,
      /chown\s+root/,
      /passwd\s+root/,
      /su\s+-/,
      /sudo\s+su/,
    ];

    return events
      .filter(
        (event) =>
          event.type === "COMMAND_EXECUTED" &&
          dangerousPatterns.some((pattern) => pattern.test(event.command))
      )
      .map((event) => event.command);
  }

  // Получение доступа к чувствительным файлам
  getSensitiveFileAccess(session) {
    const events = this.sessionEvents.get(session.id) || [];
    const sensitivePatterns = [
      /\/etc\/passwd/,
      /\/etc\/shadow/,
      /\/etc\/sudoers/,
      /\/root\//,
      /\/home\/[^\/]+\/\.ssh/,
    ];

    return events
      .filter(
        (event) =>
          event.type === "FILE_ACCESS" &&
          sensitivePatterns.some((pattern) => pattern.test(event.filePath))
      )
      .map((event) => event.filePath);
  }

  // Срабатывание алерта
  triggerAlert(monitoring, alertType, details) {
    const alert = {
      id: this.generateAlertId(),
      sessionId: monitoring.sessionId,
      type: alertType,
      details: details,
      timestamp: new Date(),
      status: "ACTIVE",
      severity: this.getAlertSeverity(alertType),
    };

    // Сохранение алерта
    this.alerts.set(alert.id, alert);
    monitoring.alerts.push(alert);

    // Отправка уведомления
    this.sendAlertNotification(alert);

    return alert;
  }

  // Получение серьезности алерта
  getAlertSeverity(alertType) {
    const severityMap = {
      MULTIPLE_FAILED_LOGINS: "HIGH",
      DANGEROUS_COMMANDS: "CRITICAL",
      SENSITIVE_FILE_ACCESS: "HIGH",
      SESSION_EXPIRED: "LOW",
      SESSION_INACTIVE: "MEDIUM",
    };

    return severityMap[alertType] || "MEDIUM";
  }

  // Отправка уведомления об алерте
  sendAlertNotification(alert) {
    // Упрощенная отправка уведомления
    console.log(`ALERT: ${alert.type} - ${alert.details}`, alert);

    // В реальной реализации здесь будет отправка email, SMS, Slack и т.д.
  }

  // Остановка мониторинга сессии
  stopSessionMonitoring(monitoring) {
    if (monitoring.intervalId) {
      clearInterval(monitoring.intervalId);
      monitoring.intervalId = null;
    }

    monitoring.status = "STOPPED";
    monitoring.stoppedAt = new Date();
  }

  // Логирование события сессии
  logSessionEvent(sessionId, eventType, details) {
    const event = {
      id: this.generateEventId(),
      sessionId: sessionId,
      type: eventType,
      details: details,
      timestamp: new Date(),
    };

    const events = this.sessionEvents.get(sessionId) || [];
    events.push(event);
    this.sessionEvents.set(sessionId, events);

    return event;
  }

  // Генерация ID мониторинга
  generateMonitoringId() {
    return "mon_" + Date.now() + "_" + Math.random().toString(36).substr(2, 8);
  }

  // Генерация ID алерта
  generateAlertId() {
    return (
      "alert_" + Date.now() + "_" + Math.random().toString(36).substr(2, 8)
    );
  }

  // Генерация ID события
  generateEventId() {
    return (
      "event_" + Date.now() + "_" + Math.random().toString(36).substr(2, 8)
    );
  }
}

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

1. Privileged Account Management

• Account Discovery — обнаружение аккаунтов
• Password Management — управление паролями
• Access Control — контроль доступа
• Session Management — управление сессиями

2. Session Monitoring

• Real-time Monitoring — мониторинг в реальном времени
• Session Recording — запись сессий
• Activity Tracking — отслеживание активности
• Alert Management — управление алертами

3. Compliance and Auditing

• Audit Logging — логирование аудита
• Compliance Reporting — отчеты о соответствии
• Forensic Analysis — криминалистический анализ
• Regulatory Compliance — соответствие требованиям

Best Practices

1. Implementation

• Inventory Management — управление инвентарем
• Password Policies — политики паролей
• Access Controls — контроль доступа
• Regular Reviews — регулярные обзоры

2. Monitoring

• Session Recording — запись сессий
• Activity Monitoring — мониторинг активности
• Alert Management — управление алертами
• Incident Response — реагирование на инциденты

3. Security

• Multi-Factor Authentication — многофакторная аутентификация
• Encryption — шифрование
• Access Logging — логирование доступа
• Regular Updates — регулярные обновления

Заключение

PAM — это критически важная система для управления привилегированными доступами, которая требует:

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

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

---

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