Authorization — কে কী করতে পারবে, RBAC থেকে ABAC পর্যন্ত

RBAC engine — আসলেই বানিয়ে চালানো

নিচের কোডটা একটা ছোট কিন্তু আসল RBAC engine — কোনো library নয়, নিয়ম তিনটা: role-এ permission যোগ করা, user-কে role assign করা, আর can(user, permission) জিজ্ঞেস করা। Scenario: একটা কোম্পানির expense-approval সিস্টেম — bob engineering দলের manager (তার approval-limit $500), carol sales দলের manager (তার approval-limit$50,000)।

# rbac_engine.py — একটা ছোট কিন্তু আসল RBAC engine: user -> role -> permission
class RBACEngine:
    def __init__(self):
        self.role_permissions = {}   # role -> set(permission)
        self.user_roles = {}         # user -> set(role)

    def add_role(self, role, permissions):
        self.role_permissions[role] = set(permissions)

    def assign_role(self, user, role):
        self.user_roles.setdefault(user, set()).add(role)

    def permissions_of(self, user):
        perms = set()
        for role in self.user_roles.get(user, ()):
            perms |= self.role_permissions.get(role, set())
        return perms

    def can(self, user, permission):
        return permission in self.permissions_of(user)


rbac = RBACEngine()
rbac.add_role("employee", ["view_own_expense", "submit_expense"])
rbac.add_role("manager", ["view_own_expense", "submit_expense", "approve_expense"])
rbac.add_role("finance", ["view_own_expense", "submit_expense", "approve_expense", "export_ledger"])

rbac.assign_role("alice", "employee")
rbac.assign_role("bob", "manager")       # bob: engineering দলের manager, approval limit $500
rbac.assign_role("carol", "manager")     # carol: sales দলের manager, approval limit $50,000
rbac.assign_role("dave", "finance")

requests = [
    ("alice", "view_own_expense"),
    ("alice", "approve_expense"),
    ("bob", "approve_expense"),
    ("carol", "approve_expense"),
    ("dave", "export_ledger"),
]

print("RBAC decisions (role-level permission — amount/department কিছুই দেখছে না):")
for user, perm in requests:
    decision = rbac.can(user, perm)
    print(f"  can({user:6}, {perm:20}) = {decision}")

print()
print("সমস্যা: bob (limit $500) আর carol (limit $50,000) — RBAC-এর চোখে দুইজনই")
print("শুধু 'manager', তাই 'approve_expense' permission-এ কোনো তফাত নেই:")
for user in ("bob", "carol"):
    print(f"  can({user:6}, approve_expense) = {rbac.can(user, 'approve_expense')}  "
          f"(amount/department-নির্বিশেষে সবসময় True)")

প্রত্যাশিত output (deterministic — হুবহু এটাই আসবে):

RBAC decisions (role-level permission — amount/department কিছুই দেখছে না):
  can(alice , view_own_expense    ) = True
  can(alice , approve_expense     ) = False
  can(bob   , approve_expense     ) = True
  can(carol , approve_expense     ) = True
  can(dave  , export_ledger       ) = True

সমস্যা: bob (limit $500) আর carol (limit $50,000) — RBAC-এর চোখে দুইজনই
শুধু 'manager', তাই 'approve_expense' permission-এ কোনো তফাত নেই:
  can(bob   , approve_expense) = True  (amount/department-নির্বিশেষে সবসময় True)
  can(carol , approve_expense) = True  (amount/department-নির্বিশেষে সবসময় True)

এই output-ই RBAC-এর coarse-grained সীমাবদ্ধতা নিজেই বলে দিচ্ছে: can() ফাংশনটা bob-কে $50,000-এর expense approve করতে দেবে কিনা জিজ্ঞেস করলেও একই True ফেরত দেবে — কারণ RBAC-এর role/permission মডেলে amount নামে কোনো ধারণাই নেই। Permission হয় আছে, নয় নেই — মাঝামাঝি কোনো শর্ত এখানে বসানোর জায়গা নেই।

ABAC evaluator — একই scenario, এবার policy দিয়ে

এখন একই scenario-য় একটা ABAC policy লিখি — একটাই ফাংশন, চারটা attribute-গ্রুপ (এখানে environment খালি, আজ দরকার নেই) বিবেচনা করে:

# abac_engine.py — একই expense-approval scenario, এবার ABAC দিয়ে
def abac_allow(subject, resource, action, environment):
    # policy: manager নিজের department-এর expense approve করতে পারবে,
    # কিন্তু শুধু নিজের approval_limit-এর মধ্যে থাকলে
    if action != "approve_expense":
        return False
    if subject["role"] not in ("manager", "finance"):
        return False
    if subject["role"] == "finance":
        return True  # finance role-এর কোনো limit/department restriction নেই
    same_department = subject["department"] == resource["department"]
    within_limit = resource["amount"] <= subject["approval_limit"]
    return same_department and within_limit


subjects = {
    "bob":   {"role": "manager", "department": "engineering", "approval_limit": 500},
    "carol": {"role": "manager", "department": "sales",       "approval_limit": 50000},
    "dave":  {"role": "finance", "department": "finance",     "approval_limit": None},
}

# প্রতিটা resource-এর নিজস্ব amount আর department থাকে — RBAC এই দুইটা কখনো দেখেইনি
resources = {
    "exp-101": {"department": "engineering", "amount": 300},     # bob-এর limit-এর ভেতরে
    "exp-102": {"department": "engineering", "amount": 4000},    # bob-এর limit ছাড়িয়ে গেছে
    "exp-103": {"department": "sales",       "amount": 4000},    # carol-এর department, limit-এর ভেতরে
    "exp-104": {"department": "sales",       "amount": 4000},    # bob-এর department না — bob-এর নয়
}

test_cases = [
    ("bob",   "exp-101", "approve_expense"),  # bob নিজ department, limit-এর ভেতরে -> allow
    ("bob",   "exp-102", "approve_expense"),  # bob নিজ department, কিন্তু limit ছাড়িয়ে -> deny
    ("bob",   "exp-104", "approve_expense"),  # bob-এর department না -> deny
    ("carol", "exp-103", "approve_expense"),  # carol নিজ department, limit-এর ভেতরে -> allow
    ("dave",  "exp-102", "approve_expense"),  # finance -> সবসময় allow
]

print("ABAC decisions (policy attribute-ভিত্তিক — role + department + amount + limit):")
for user, res_id, action in test_cases:
    subject = subjects[user]
    resource = resources[res_id]
    decision = abac_allow(subject, resource, action, environment={})
    print(f"  allow({user:6}, {res_id}, amount=${resource['amount']:<6}"
          f"dept={resource['department']:11}) = {decision}")

print()
print("তুলনা — একই দুইটা request, RBAC আর ABAC-এর সিদ্ধান্ত পাশাপাশি:")
print(f"  RBAC  can(bob, approve_expense)                         = True   (সবসময়, blind)")
print(f"  ABAC  allow(bob, exp-102 [$4000, engineering])           = "
      f"{abac_allow(subjects['bob'], resources['exp-102'], 'approve_expense', {})}"
      f"  (limit ছাড়িয়ে গেছে বলে deny)")
print(f"  ABAC  allow(bob, exp-104 [$4000, sales])                 = "
      f"{abac_allow(subjects['bob'], resources['exp-104'], 'approve_expense', {})}"
      f"  (bob-এর department না বলে deny)")

প্রত্যাশিত output (deterministic — হুবহু এটাই আসবে):

ABAC decisions (policy attribute-ভিত্তিক — role + department + amount + limit):
  allow(bob   , exp-101, amount=$300   dept=engineering) = True
  allow(bob   , exp-102, amount=$4000  dept=engineering) = False
  allow(bob   , exp-104, amount=$4000  dept=sales      ) = False
  allow(carol , exp-103, amount=$4000  dept=sales      ) = True
  allow(dave  , exp-102, amount=$4000  dept=engineering) = True

তুলনা — একই দুইটা request, RBAC আর ABAC-এর সিদ্ধান্ত পাশাপাশি:
  RBAC  can(bob, approve_expense)                         = True   (সবসময়, blind)
  ABAC  allow(bob, exp-102 [$4000, engineering])           = False  (limit ছাড়িয়ে গেছে বলে deny)
  ABAC  allow(bob, exp-104 [$4000, sales])                 = False  (bob-এর department না বলে deny)

এই তুলনাটাই আজকের কেন্দ্রীয় প্রমাণ: exp-102 (bob-এর নিজের department, কিন্তু limit ছাড়িয়ে যাওয়া) আর exp-104 (bob-এর limit-এর ভেতরে হলেও ভিন্ন department) — দুইটা ক্ষেত্রেই RBAC কিছুই বলতে পারে না, কারণ তার কাছে amount বা department নামে কোনো ধারণাই নেই — শুধু approve_expense permission আছে কিনা, যেটা bob-এর জন্য সবসময় True। ABAC ঠিক এই দুইটা ক্ষেত্রেই সঠিকভাবে False বলে দিচ্ছে, কারণ তার policy সরাসরি resource-এর attribute (amount, department) subject-এর attribute-এর (approval_limit, department) সাথে তুলনা করছে। এটাই ABAC-এর expressiveness-এর সংজ্ঞাগত প্রমাণ — কোনো hand-wave নয়, একই কোড, একই input, ভিন্ন সিদ্ধান্ত-প্রক্রিয়া।