Авторизация

Что такое авторизация?

Авторизация (Authorization) — это процесс определения прав доступа пользователя к ресурсам системы после успешной аутентификации.

Отличие от аутентификации

• Аутентификация — “Кто вы?” (подтверждение личности)
• Авторизация — “Что вы можете делать?” (определение прав доступа)

Принципы авторизации

• Principle of Least Privilege — принцип минимальных привилегий
• Separation of Duties — разделение обязанностей
• Need-to-Know — необходимость знать
• Defense in Depth — многоуровневая защита

Модели авторизации

RBAC (Role-Based Access Control)

Управление доступом на основе ролей

Компоненты RBAC:

• Users — пользователи
• Roles — роли
• Permissions — права
• Resources — ресурсы

Связи:

User → Role → Permission → Resource

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

// RBAC система
class RBACSystem {
  constructor() {
    this.users = new Map();
    this.roles = new Map();
    this.permissions = new Map();
    this.userRoles = new Map();
    this.rolePermissions = new Map();
    this.resources = new Map();
  }

  createRole(roleId, roleName, description) {
    // Создание роли
    this.roles.set(roleId, {
      name: roleName,
      description: description,
      createdAt: new Date(),
    });
  }

  assignRole(userId, roleId) {
    // Назначение роли пользователю
    if (!this.userRoles.has(userId)) {
      this.userRoles.set(userId, []);
    }
    const userRoles = this.userRoles.get(userId);
    userRoles.push(roleId);
  }

  grantPermission(roleId, permissionId) {
    // Предоставление права роли
    if (!this.rolePermissions.has(roleId)) {
      this.rolePermissions.set(roleId, []);
    }
    const rolePermissions = this.rolePermissions.get(roleId);
    rolePermissions.push(permissionId);
  }

  checkPermission(userId, resource, action) {
    // Проверка прав доступа
    const userRoles = this.userRoles.get(userId) || [];
    for (const roleId of userRoles) {
      const rolePermissions = this.rolePermissions.get(roleId) || [];
      for (const permissionId of rolePermissions) {
        const permission = this.permissions.get(permissionId);
        if (
          permission &&
          permission.resource === resource &&
          permission.action === action
        ) {
          return true;
        }
      }
    }
    return false;
  }
}

Пример ролей:

# Роли в системе
roles:
  admin:
    name: "System Administrator"
    description: "Full system access"
    permissions:
      - "read:all"
      - "write:all"
      - "delete:all"
      - "manage:users"
      - "manage:roles"

  developer:
    name: "Software Developer"
    description: "Development access"
    permissions:
      - "read:code"
      - "write:code"
      - "deploy:staging"
      - "read:documentation"

  manager:
    name: "Project Manager"
    description: "Management access"
    permissions:
      - "read:projects"
      - "write:projects"
      - "manage:team"
      - "view:reports"

  user:
    name: "Regular User"
    description: "Basic user access"
    permissions:
      - "read:own_data"
      - "write:own_data"
      - "read:public_docs"

ABAC (Attribute-Based Access Control)

Управление доступом на основе атрибутов

Атрибуты:

• Subject Attributes — атрибуты субъекта
• Resource Attributes — атрибуты ресурса
• Action Attributes — атрибуты действия
• Environment Attributes — атрибуты окружения

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

// ABAC система
class ABACSystem {
  constructor() {
    this.policies = [];
    this.attributes = new Map();
  }

  addPolicy(policy) {
    // Добавление политики
    this.policies.push(policy);
  }

  evaluateAccess(subject, resource, action, environment) {
    // Оценка доступа
    const context = {
      subject: subject,
      resource: resource,
      action: action,
      environment: environment,
    };

    for (const policy of this.policies) {
      if (this.evaluatePolicy(policy, context)) {
        return policy.effect === "permit";
      }
    }

    return false; // По умолчанию запрет
  }

  evaluatePolicy(policy, context) {
    // Оценка политики
    for (const rule of policy.rules) {
      if (this.evaluateRule(rule, context)) {
        return true;
      }
    }
    return false;
  }

  evaluateRule(rule, context) {
    // Оценка правила
    // Простая реализация - в реальности нужен парсер выражений
    const condition = rule.condition;
    return this.evaluateCondition(condition, context);
  }
}

Пример политики:

# ABAC политика
policy:
  name: "Document Access Policy"
  rules:
    - name: "Department Access"
      condition: |
        subject.department == resource.department AND
        subject.clearance_level >= resource.classification AND
        environment.time >= "09:00" AND
        environment.time <= "18:00"
      effect: "permit"

    - name: "Manager Override"
      condition: |
        subject.role == "manager" AND
        subject.department == resource.department
      effect: "permit"

    - name: "Emergency Access"
      condition: |
        environment.emergency == true AND
        subject.role == "admin"
      effect: "permit"

    - name: "Default Deny"
      condition: "true"
      effect: "deny"

DAC (Discretionary Access Control)

Дискреционное управление доступом

Принципы:

• Owner Control — контроль владельца
• Access Control Lists — списки контроля доступа
• User Discretion — дискреция пользователя
• Inheritance — наследование прав

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

// DAC система
class DACSystem {
  constructor() {
    this.acls = new Map();
    this.owners = new Map();
  }

  setOwner(resourceId, userId) {
    // Установка владельца ресурса
    this.owners.set(resourceId, userId);
  }

  grantAccess(resourceId, userId, permissions) {
    // Предоставление доступа
    if (!this.acls.has(resourceId)) {
      this.acls.set(resourceId, new Map());
    }
    this.acls.get(resourceId).set(userId, permissions);
  }

  revokeAccess(resourceId, userId) {
    // Отзыв доступа
    if (this.acls.has(resourceId)) {
      this.acls.get(resourceId).delete(userId);
    }
  }

  checkAccess(userId, resourceId, action) {
    // Проверка доступа
    // Проверка владельца
    if (this.owners.get(resourceId) === userId) {
      return true;
    }

    // Проверка ACL
    if (this.acls.has(resourceId)) {
      const userPermissions = this.acls.get(resourceId).get(userId);
      if (userPermissions && userPermissions.includes(action)) {
        return true;
      }
    }

    return false;
  }
}

Пример ACL:

# Access Control List
acl:
  resource: "/documents/project_alpha"
  owner: "user_12345"
  permissions:
    - user: "user_12345"
      rights: ["read", "write", "execute", "delete"]
    - user: "user_67890"
      rights: ["read", "write"]
    - group: "developers"
      rights: ["read"]
    - group: "managers"
      rights: ["read", "write"]
    - group: "everyone"
      rights: ["read"]

MAC (Mandatory Access Control)

Принудительное управление доступом

Принципы:

• Security Labels — метки безопасности
• System Control — системный контроль
• No User Discretion — отсутствие дискреции пользователя
• Hierarchical Levels — иерархические уровни

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

// MAC система
class MACSystem {
  constructor() {
    this.securityLevels = [
      "unclassified",
      "confidential",
      "secret",
      "top_secret",
    ];
    this.categories = ["project_alpha", "project_beta", "financial", "hr"];
  }

  getUserClearance(userId) {
    // Получение уровня доступа пользователя
    return {
      level: "secret",
      categories: ["project_alpha", "financial"],
    };
  }

  getResourceClassification(resourceId) {
    // Получение классификации ресурса
    return {
      level: "confidential",
      categories: ["project_alpha"],
    };
  }

  checkAccess(userId, resourceId) {
    // Проверка доступа по MAC
    const userClearance = this.getUserClearance(userId);
    const resourceClassification = this.getResourceClassification(resourceId);

    // Проверка уровня доступа
    const userLevelIndex = this.securityLevels.indexOf(userClearance.level);
    const resourceLevelIndex = this.securityLevels.indexOf(
      resourceClassification.level
    );

    if (userLevelIndex < resourceLevelIndex) {
      return false;
    }

    // Проверка категорий
    for (const category of resourceClassification.categories) {
      if (!userClearance.categories.includes(category)) {
        return false;
      }
    }

    return true;
  }
}

Управление ролями

Создание ролей

Процесс создания и управления ролями

Этапы создания роли:

1. Анализ требований — определение потребностей
2. Определение прав — выбор необходимых прав
3. Создание роли — создание роли в системе
4. Тестирование — проверка работы роли
5. Развертывание — внедрение роли

Пример процесса:

# Процесс создания роли
role_creation:
  step_1:
    name: "Requirements Analysis"
    description: "Analyze business requirements"
    activities:
      - "Interview stakeholders"
      - "Document access needs"
      - "Identify resources"
      - "Define permissions"

  step_2:
    name: "Role Design"
    description: "Design role structure"
    activities:
      - "Define role hierarchy"
      - "Map permissions to roles"
      - "Create role relationships"
      - "Document role purpose"

  step_3:
    name: "Implementation"
    description: "Implement role in system"
    activities:
      - "Create role in IAM system"
      - "Configure permissions"
      - "Set up role assignments"
      - "Test role functionality"

  step_4:
    name: "Deployment"
    description: "Deploy role to production"
    activities:
      - "Assign role to users"
      - "Monitor role usage"
      - "Collect feedback"
      - "Optimize role configuration"

Управление жизненным циклом ролей

Управление ролями на протяжении их жизненного цикла

Этапы жизненного цикла:

• Creation — создание
• Assignment — назначение
• Modification — модификация
• Review — пересмотр
• Retirement — вывод из эксплуатации

Пример процесса:

// Управление жизненным циклом ролей
class RoleLifecycleManager {
  constructor() {
    this.roles = new Map();
    this.roleHistory = new Map();
  }

  createRole(roleId, roleData) {
    // Создание роли
    this.roles.set(roleId, {
      ...roleData,
      status: "active",
      createdAt: new Date(),
      version: 1,
    });
    this.roleHistory.set(roleId, [
      {
        action: "created",
        timestamp: new Date(),
        data: roleData,
      },
    ]);
  }

  modifyRole(roleId, changes) {
    // Модификация роли
    if (this.roles.has(roleId)) {
      const oldData = { ...this.roles.get(roleId) };
      const role = this.roles.get(roleId);
      Object.assign(role, changes);
      role.version += 1;
      role.modifiedAt = new Date();

      this.roleHistory.get(roleId).push({
        action: "modified",
        timestamp: new Date(),
        changes: changes,
        oldData: oldData,
      });
    }
  }

  retireRole(roleId) {
    // Вывод роли из эксплуатации
    if (this.roles.has(roleId)) {
      const role = this.roles.get(roleId);
      role.status = "retired";
      role.retiredAt = new Date();

      this.roleHistory.get(roleId).push({
        action: "retired",
        timestamp: new Date(),
      });
    }
  }
}

Политики доступа

Создание политик

Создание и управление политиками доступа

Типы политик:

• Access Policies — политики доступа
• Data Policies — политики данных
• Network Policies — сетевые политики
• Application Policies — политики приложений

Пример политики:

# Политика доступа к данным
data_access_policy:
  name: "Customer Data Access Policy"
  description: "Policy for accessing customer data"
  rules:
    - name: "HR Access"
      condition: |
        subject.department == "HR" AND
        subject.role == "hr_manager" AND
        resource.type == "customer_personal_data"
      effect: "permit"
      actions: ["read", "update"]

    - name: "Sales Access"
      condition: |
        subject.department == "Sales" AND
        subject.role == "sales_rep" AND
        resource.type == "customer_contact_info" AND
        subject.territory == resource.territory
      effect: "permit"
      actions: ["read"]

    - name: "IT Access"
      condition: |
        subject.department == "IT" AND
        subject.role == "admin" AND
        environment.emergency == true
      effect: "permit"
      actions: ["read", "update", "delete"]

    - name: "Default Deny"
      condition: "true"
      effect: "deny"

Управление политиками

Управление жизненным циклом политик

Процессы:

• Policy Creation — создание политик
• Policy Review — пересмотр политик
• Policy Testing — тестирование политик
• Policy Deployment — развертывание политик
• Policy Monitoring — мониторинг политик

Пример системы:

// Система управления политиками
class PolicyManager {
  constructor() {
    this.policies = new Map();
    this.policyVersions = new Map();
    this.policyTests = new Map();
  }

  createPolicy(policyId, policyData) {
    // Создание политики
    this.policies.set(policyId, {
      ...policyData,
      status: "draft",
      createdAt: new Date(),
      version: 1,
    });
  }

  testPolicy(policyId, testCases) {
    // Тестирование политики
    const policy = this.policies.get(policyId);
    const testResults = [];

    for (const testCase of testCases) {
      const result = this.evaluatePolicy(policy, testCase);
      testResults.push({
        testCase: testCase,
        result: result,
        expected: testCase.expected,
        passed: result === testCase.expected,
      });
    }

    this.policyTests.set(policyId, testResults);
    return testResults;
  }

  deployPolicy(policyId) {
    // Развертывание политики
    if (this.policies.has(policyId)) {
      const policy = this.policies.get(policyId);
      policy.status = "active";
      policy.deployedAt = new Date();
    }
  }

  monitorPolicy(policyId) {
    // Мониторинг политики
    const policy = this.policies.get(policyId);
    // Логика мониторинга
    return {
      policyId: policyId,
      status: policy.status,
      usageCount: 0, // Заглушка
      violations: 0, // Заглушка
      lastAccessed: new Date(),
    };
  }
}

Лучшие практики

Рекомендации

• Используйте принцип минимальных привилегий — давайте только необходимые права
• Реализуйте разделение обязанностей — не давайте одному пользователю слишком много прав
• Регулярно пересматривайте права — проверяйте актуальность прав доступа
• Документируйте политики — ведите документацию политик
• Мониторьте использование — отслеживайте использование прав

Чего избегать

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

Метрики и KPI

Операционные метрики

• Permission Grant Time — время предоставления прав
• Access Request Time — время обработки запросов
• Policy Evaluation Time — время оценки политик
• Role Assignment Time — время назначения ролей

Качественные метрики

• Access Accuracy — точность предоставления доступа
• Policy Compliance — соответствие политикам
• User Satisfaction — удовлетворенность пользователей
• Security Score — оценка безопасности

Бизнес-метрики

• Cost per Permission — стоимость на право
• ROI — возврат инвестиций
• Risk Reduction — снижение рисков
• Productivity Impact — воздействие на производительность

Заключение

Авторизация — это критически важный компонент системы безопасности. Успешная реализация авторизации требует:

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

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