RBAC vs ABAC - Role-Based vs Attribute-Based Access Control

Что такое RBAC vs ABAC?

RBAC (Role-Based Access Control) — это модель контроля доступа, основанная на ролях пользователей. ABAC (Attribute-Based Access Control) — это модель контроля доступа, основанная на атрибутах субъектов, ресурсов, действий и окружения. Сравнение этих моделей помогает выбрать оптимальный подход для управления доступом в организации.

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

• RBAC — ролевой контроль доступа
• ABAC — атрибутный контроль доступа
• Access Control Models — модели контроля доступа
• Security Policies — политики безопасности
• Permission Management — управление разрешениями

Архитектура RBAC vs ABAC

1. RBAC Implementation

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

  // Создание пользователя
  createUser(userData) {
    const user = {
      id: this.generateUserId(),
      username: userData.username,
      email: userData.email,
      firstName: userData.firstName,
      lastName: userData.lastName,
      status: "ACTIVE",
      createdAt: new Date(),
      updatedAt: new Date(),
    };

    // Валидация данных пользователя
    const validation = this.validateUserData(user);
    if (!validation.isValid) {
      throw new Error(
        `User validation failed: ${validation.errors.join(", ")}`
      );
    }

    // Сохранение пользователя
    this.users.set(user.id, user);

    return user;
  }

  // Валидация данных пользователя
  validateUserData(user) {
    const errors = [];

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

    if (!user.email || user.email.trim() === ") {
      errors.push("Email is required");
    }

    if (!this.isValidEmail(user.email)) {
      errors.push("Invalid email format");
    }

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

  // Создание роли
  createRole(roleData) {
    const role = {
      id: this.generateRoleId(),
      name: roleData.name,
      description: roleData.description,
      type: roleData.type || "CUSTOM", // SYSTEM, CUSTOM
      status: "ACTIVE",
      createdAt: new Date(),
      updatedAt: new Date(),
    };

    // Валидация данных роли
    const validation = this.validateRoleData(role);
    if (!validation.isValid) {
      throw new Error(
        `Role validation failed: ${validation.errors.join(", ")}`
      );
    }

    // Сохранение роли
    this.roles.set(role.id, role);

    return role;
  }

  // Валидация данных роли
  validateRoleData(role) {
    const errors = [];

    if (!role.name || role.name.trim() === ") {
      errors.push("Role name is required");
    }

    if (this.roles.has(role.name)) {
      errors.push("Role name already exists");
    }

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

  // Создание разрешения
  createPermission(permissionData) {
    const permission = {
      id: this.generatePermissionId(),
      name: permissionData.name,
      description: permissionData.description,
      resource: permissionData.resource,
      action: permissionData.action,
      conditions: permissionData.conditions || [],
      status: "ACTIVE",
      createdAt: new Date(),
      updatedAt: new Date(),
    };

    // Валидация данных разрешения
    const validation = this.validatePermissionData(permission);
    if (!validation.isValid) {
      throw new Error(
        `Permission validation failed: ${validation.errors.join(", ")}`
      );
    }

    // Сохранение разрешения
    this.permissions.set(permission.id, permission);

    return permission;
  }

  // Валидация данных разрешения
  validatePermissionData(permission) {
    const errors = [];

    if (!permission.name || permission.name.trim() === ") {
      errors.push("Permission name is required");
    }

    if (!permission.resource || permission.resource.trim() === ") {
      errors.push("Resource is required");
    }

    if (!permission.action || permission.action.trim() === ") {
      errors.push("Action is required");
    }

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

  // Назначение роли пользователю
  assignRoleToUser(userId, roleId) {
    const user = this.users.get(userId);
    if (!user) {
      throw new Error("User not found");
    }

    const role = this.roles.get(roleId);
    if (!role) {
      throw new Error("Role not found");
    }

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

    // Проверка на существующее назначение
    const existingAssignments = this.userRoles.get(userId) || [];
    if (existingAssignments.includes(roleId)) {
      throw new Error("Role already assigned to user");
    }

    // Добавление роли
    existingAssignments.push(roleId);
    this.userRoles.set(userId, existingAssignments);

    return {
      userId: userId,
      roleId: roleId,
      assignedAt: new Date(),
    };
  }

  // Назначение разрешения роли
  assignPermissionToRole(roleId, permissionId) {
    const role = this.roles.get(roleId);
    if (!role) {
      throw new Error("Role not found");
    }

    const permission = this.permissions.get(permissionId);
    if (!permission) {
      throw new Error("Permission not found");
    }

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

    // Проверка на существующее назначение
    const existingAssignments = this.rolePermissions.get(roleId) || [];
    if (existingAssignments.includes(permissionId)) {
      throw new Error("Permission already assigned to role");
    }

    // Добавление разрешения
    existingAssignments.push(permissionId);
    this.rolePermissions.set(roleId, existingAssignments);

    return {
      roleId: roleId,
      permissionId: permissionId,
      assignedAt: new Date(),
    };
  }

  // Проверка доступа
  checkAccess(userId, resource, action) {
    const user = this.users.get(userId);
    if (!user) {
      return {
        granted: false,
        reason: "User not found",
      };
    }

    if (user.status !== "ACTIVE") {
      return {
        granted: false,
        reason: "User is not active",
      };
    }

    // Получение ролей пользователя
    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 {
            granted: true,
            reason: "Access granted via role",
            roleId: roleId,
            permissionId: permissionId,
          };
        }
      }
    }

    return {
      granted: false,
      reason: "No matching permission found",
    };
  }

  // Получение всех разрешений пользователя
  getUserPermissions(userId) {
    const user = this.users.get(userId);
    if (!user) {
      return [];
    }

    const userRoles = this.userRoles.get(userId) || [];
    const permissions = [];

    for (const roleId of userRoles) {
      const rolePermissions = this.rolePermissions.get(roleId) || [];

      for (const permissionId of rolePermissions) {
        const permission = this.permissions.get(permissionId);
        if (permission) {
          permissions.push(permission);
        }
      }
    }

    return permissions;
  }

  // Генерация ID пользователя
  generateUserId() {
    return "user_" + Date.now() + "_" + Math.random().toString(36).substr(2, 8);
  }

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

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

  // Проверка валидности email
  isValidEmail(email) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(email);
  }
}

2. ABAC Implementation

// Система реализации ABAC
class ABACSystem {
  constructor() {
    this.policies = new Map();
    this.attributes = new Map();
    this.resources = new Map();
    this.subjects = new Map();
    this.environments = new Map();
  }

  // Создание политики
  createPolicy(policyData) {
    const policy = {
      id: this.generatePolicyId(),
      name: policyData.name,
      description: policyData.description,
      rules: policyData.rules || [],
      effect: policyData.effect || "PERMIT", // PERMIT, DENY
      priority: policyData.priority || 0,
      status: "ACTIVE",
      createdAt: new Date(),
      updatedAt: new Date(),
    };

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

    // Сохранение политики
    this.policies.set(policy.id, policy);

    return policy;
  }

  // Валидация данных политики
  validatePolicyData(policy) {
    const errors = [];

    if (!policy.name || policy.name.trim() === ") {
      errors.push("Policy name is required");
    }

    if (!policy.rules || policy.rules.length === 0) {
      errors.push("At least one rule is required");
    }

    if (!["PERMIT", "DENY"].includes(policy.effect)) {
      errors.push("Invalid policy effect");
    }

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

  // Создание правила
  createRule(ruleData) {
    const rule = {
      id: this.generateRuleId(),
      name: ruleData.name,
      description: ruleData.description,
      target: ruleData.target || {},
      condition: ruleData.condition || {},
      effect: ruleData.effect || "PERMIT",
      priority: ruleData.priority || 0,
      status: "ACTIVE",
      createdAt: new Date(),
      updatedAt: new Date(),
    };

    // Валидация данных правила
    const validation = this.validateRuleData(rule);
    if (!validation.isValid) {
      throw new Error(
        `Rule validation failed: ${validation.errors.join(", ")}`
      );
    }

    return rule;
  }

  // Валидация данных правила
  validateRuleData(rule) {
    const errors = [];

    if (!rule.name || rule.name.trim() === ") {
      errors.push("Rule name is required");
    }

    if (!rule.target || Object.keys(rule.target).length === 0) {
      errors.push("Rule target is required");
    }

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

  // Создание атрибута
  createAttribute(attributeData) {
    const attribute = {
      id: this.generateAttributeId(),
      name: attributeData.name,
      type: attributeData.type, // STRING, NUMBER, BOOLEAN, DATE, ARRAY
      category: attributeData.category, // SUBJECT, RESOURCE, ACTION, ENVIRONMENT
      values: attributeData.values || [],
      status: "ACTIVE",
      createdAt: new Date(),
      updatedAt: new Date(),
    };

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

    // Сохранение атрибута
    this.attributes.set(attribute.id, attribute);

    return attribute;
  }

  // Валидация данных атрибута
  validateAttributeData(attribute) {
    const errors = [];

    if (!attribute.name || attribute.name.trim() === ") {
      errors.push("Attribute name is required");
    }

    if (
      !["STRING", "NUMBER", "BOOLEAN", "DATE", "ARRAY"].includes(attribute.type)
    ) {
      errors.push("Invalid attribute type");
    }

    if (
      !["SUBJECT", "RESOURCE", "ACTION", "ENVIRONMENT"].includes(
        attribute.category
      )
    ) {
      errors.push("Invalid attribute category");
    }

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

  // Проверка доступа
  checkAccess(request) {
    const { subject, resource, action, environment } = request;

    // Получение всех активных политик
    const activePolicies = Array.from(this.policies.values())
      .filter((p) => p.status === "ACTIVE")
      .sort((a, b) => b.priority - a.priority);

    // Проверка каждой политики
    for (const policy of activePolicies) {
      const result = this.evaluatePolicy(
        policy,
        subject,
        resource,
        action,
        environment
      );

      if (result.matched) {
        return {
          granted: result.effect === "PERMIT",
          reason: `Policy ${policy.name} ${result.effect}`,
          policyId: policy.id,
          ruleId: result.ruleId,
        };
      }
    }

    return {
      granted: false,
      reason: "No matching policy found",
    };
  }

  // Оценка политики
  evaluatePolicy(policy, subject, resource, action, environment) {
    for (const rule of policy.rules) {
      const targetMatch = this.evaluateTarget(
        rule.target,
        subject,
        resource,
        action,
        environment
      );

      if (targetMatch) {
        const conditionMatch = this.evaluateCondition(
          rule.condition,
          subject,
          resource,
          action,
          environment
        );

        if (conditionMatch) {
          return {
            matched: true,
            effect: rule.effect,
            ruleId: rule.id,
          };
        }
      }
    }

    return {
      matched: false,
    };
  }

  // Оценка цели
  evaluateTarget(target, subject, resource, action, environment) {
    for (const [category, attributes] of Object.entries(target)) {
      const context = this.getContextByCategory(
        category,
        subject,
        resource,
        action,
        environment
      );

      for (const [attributeName, expectedValue] of Object.entries(attributes)) {
        const actualValue = context[attributeName];

        if (!this.compareValues(actualValue, expectedValue)) {
          return false;
        }
      }
    }

    return true;
  }

  // Оценка условия
  evaluateCondition(condition, subject, resource, action, environment) {
    if (!condition || Object.keys(condition).length === 0) {
      return true;
    }

    // Упрощенная оценка условия
    for (const [operator, operands] of Object.entries(condition)) {
      switch (operator) {
        case "AND":
          return operands.every((operand) =>
            this.evaluateCondition(
              operand,
              subject,
              resource,
              action,
              environment
            )
          );
        case "OR":
          return operands.some((operand) =>
            this.evaluateCondition(
              operand,
              subject,
              resource,
              action,
              environment
            )
          );
        case "NOT":
          return !this.evaluateCondition(
            operands,
            subject,
            resource,
            action,
            environment
          );
        case "EQUALS":
          return this.compareValues(operands[0], operands[1]);
        case "NOT_EQUALS":
          return !this.compareValues(operands[0], operands[1]);
        case "GREATER_THAN":
          return operands[0] > operands[1];
        case "LESS_THAN":
          return operands[0] < operands[1];
        case "CONTAINS":
          return operands[0].includes(operands[1]);
        case "NOT_CONTAINS":
          return !operands[0].includes(operands[1]);
        default:
          return false;
      }
    }

    return true;
  }

  // Получение контекста по категории
  getContextByCategory(category, subject, resource, action, environment) {
    switch (category) {
      case "SUBJECT":
        return subject;
      case "RESOURCE":
        return resource;
      case "ACTION":
        return action;
      case "ENVIRONMENT":
        return environment;
      default:
        return {};
    }
  }

  // Сравнение значений
  compareValues(actual, expected) {
    if (typeof expected === "object" && expected.operator) {
      switch (expected.operator) {
        case "EQUALS":
          return actual === expected.value;
        case "NOT_EQUALS":
          return actual !== expected.value;
        case "GREATER_THAN":
          return actual > expected.value;
        case "LESS_THAN":
          return actual < expected.value;
        case "CONTAINS":
          return actual.includes(expected.value);
        case "NOT_CONTAINS":
          return !actual.includes(expected.value);
        default:
          return false;
      }
    }

    return actual === expected;
  }

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

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

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

Основные компоненты RBAC vs ABAC

1. RBAC

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

2. ABAC

• Subjects — субъекты
• Resources — ресурсы
• Actions — действия
• Environment — окружение

3. Comparison

• Granularity — детализация
• Flexibility — гибкость
• Complexity — сложность
• Performance — производительность

Best Practices

1. RBAC

• Role Design — проектирование ролей
• Permission Management — управление разрешениями
• Regular Reviews — регулярные обзоры
• Documentation — документация

2. ABAC

• Policy Design — проектирование политик
• Attribute Management — управление атрибутами
• Testing — тестирование
• Monitoring — мониторинг

3. Hybrid Approach

• Combined Models — комбинированные модели
• Gradual Migration — постепенная миграция
• Best of Both — лучшее из обоих
• Continuous Improvement — непрерывное улучшение

Заключение

RBAC vs ABAC — это критически важное сравнение для выбора оптимальной модели контроля доступа, которое требует:

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

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

---

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