ADR-006 - מערכת הרשאות מודול

ADR-006: מערכת הרשאות מודול

מערכת הרשאות היררכית עדינה למודולים XOOPS המאפשרת בקרת גישה פרטנית.

---

סטטוס

מקובל - מיושם ב-XOOPS 2.5.x והורחב ב-XOOPS 4.0

---

הקשר

הצהרת בעיה

XOOPS מודולים צריכים בקרות הרשאות גמישות המאפשרות:

1. הרשאות ברמת המודול - האם המשתמש יכול לגשת למודול זה?
2. הרשאות ברמת האובייקט - האם המשתמש יכול לגשת לפריט הספציפי הזה?
3. הרשאות ברמת הפעולה - האם המשתמש יכול לבצע פעולה זו?
4. הרשאות מותאמות אישית - האם מודולים יכולים להגדיר הרשאות משלהם?

מצב נוכחי

XOOPS 2.5 משתמש במערכת XoopsGroupPermission:

<?php
$perm_handler = xoops_getHandler('groupperm');
$isAllowed = $perm_handler->checkRight(
    'modulename',
    'action',
    $itemId,
    $groupId
);

אתגרים

1. שאילתות מורכבות - בדיקות הרשאות דורשות הצטרפות למסד נתונים
2. היררכיה מוגבלת - קשה ליצור קבוצות הרשאות
3. Caching גרוע - אין cache מובנה של הרשאות
4. וריאציות של מודול - כל מודול מיישם אחרת
5. ביצועים - שאילתות DB מרובות לבדיקות הרשאות

---

החלטה

הטמעת מערכת הרשאות היררכית

צור מערכת הרשאות סטנדרטית, מאוחסנת בcache התומכת ב:

1. הרשאות היררכיות - ירושה מקבוצות הורים
2. גישה מבוססת תפקידים - מפה הרשאות לתפקידים (מנהל, מנחה, משתמש, אורח)
3. הרשאות אובייקט - שליטה עדינה לכל פריט
4. Caching - הרשאות cache לצמצום שאילתות
5. הרשאות מותאמות אישית - מודולים מגדירים משלהם
6. שביל ביקורת - יומן שינויים בהרשאות

היררכיית הרשאות

User
  └── Group 1 (Admin)
      └── Permission: admin_module
      └── Permission: edit_all_items
      └── Permission: delete_all_items
  └── Group 2 (Moderator)
      └── Permission: moderate_comments
      └── Permission: edit_own_items
  └── Group 3 (User)
      └── Permission: view_published_items
      └── Permission: edit_own_items
  └── Group 4 (Guest)
      └── Permission: view_published_items

אדריכלות

graph TB
    subgraph "Permission System"
        A["Permission Registry<br/>(Define permissions)"]
        B["Permission Checker<br/>(Check access)"]
        C["Permission Cache<br/>(Improve performance)"]
        D["Permission Audit Log<br/>(Track changes)"]
    end

    subgraph "Data Layer"
        E["Group Permissions Table"]
        F["User Groups Table"]
        G["Permission Definitions"]
    end

    A --> E
    B --> E
    B --> C
    C --> E
    D --> E
    F --> B

---

רכיבי ליבה

1. הגדרת הרשאה

<?php
// Module defines its permissions in xoops_version.php

$modversion['permissions'] = [
    [
        'name' => 'module_view',
        'description' => 'Can view module',
        'level' => 'module',
    ],
    [
        'name' => 'item_view',
        'description' => 'Can view items',
        'level' => 'item',
    ],
    [
        'name' => 'item_create',
        'description' => 'Can create items',
        'level' => 'item',
    ],
    [
        'name' => 'item_edit',
        'description' => 'Can edit items',
        'level' => 'item',
    ],
    [
        'name' => 'item_delete',
        'description' => 'Can delete items',
        'level' => 'item',
    ],
    [
        'name' => 'admin_manage',
        'description' => 'Can manage module',
        'level' => 'admin',
    ],
];

// Default permissions by group
$modversion['group_permissions'] = [
    // Admin group gets all permissions
    '1' => [
        'module_view' => 1,
        'item_view' => 1,
        'item_create' => 1,
        'item_edit' => 1,
        'item_delete' => 1,
        'admin_manage' => 1,
    ],
    // User group
    '3' => [
        'module_view' => 1,
        'item_view' => 1,
        'item_create' => 1,
        'item_edit' => 0,
        'item_delete' => 0,
        'admin_manage' => 0,
    ],
    // Guest group
    '4' => [
        'module_view' => 1,
        'item_view' => 1,
        'item_create' => 0,
        'item_edit' => 0,
        'item_delete' => 0,
        'admin_manage' => 0,
    ],
];

2. בודק הרשאות

<?php
declare(strict_types=1);

namespace XoopsCore\Permission;

class PermissionChecker
{
    private PermissionCache $cache;
    private PermissionRepository $repository;

    public function hasPermission(
        User $user,
        string $permissionName,
        ?int $itemId = null
    ): bool {
        // Check cache first
        $cacheKey = "perm_{$user->getId()}_{$permissionName}_{$itemId}";
        if ($this->cache->has($cacheKey)) {
            return $this->cache->get($cacheKey);
        }

        $hasPermission = false;

        // Check all user groups
        foreach ($user->getGroups() as $group) {
            if ($this->checkGroupPermission($group, $permissionName, $itemId)) {
                $hasPermission = true;
                break;
            }
        }

        // Cache result
        $this->cache->set($cacheKey, $hasPermission, 3600);

        // Log high-level access checks
        if ($hasPermission && $this->shouldAuditLog($permissionName)) {
            $this->auditLog('PERMISSION_CHECKED', [
                'user_id' => $user->getId(),
                'permission' => $permissionName,
                'item_id' => $itemId,
                'result' => 'ALLOWED',
            ]);
        }

        return $hasPermission;
    }

    private function checkGroupPermission(
        Group $group,
        string $permissionName,
        ?int $itemId = null
    ): bool {
        $sql = 'SELECT COUNT(*) FROM ' . $this->table . '
                WHERE groupid = ?
                AND permission = ?
                AND itemid = ?
                AND granted = 1';

        $stmt = $this->db->prepare($sql);
        $stmt->execute([$group->getId(), $permissionName, $itemId ?? 0]);

        return $stmt->fetchColumn() > 0;
    }
}

3. רמות הרשאה

<?php
// Different permission levels with different scopes

class PermissionLevel
{
    // Module-level: Affects entire module
    public const LEVEL_MODULE = 'module';

    // Admin-level: Admin panel access
    public const LEVEL_ADMIN = 'admin';

    // Item-level: Specific objects/items
    public const LEVEL_ITEM = 'item';

    // Field-level: Specific object fields
    public const LEVEL_FIELD = 'field';

    // Action-level: Specific actions/operations
    public const LEVEL_ACTION = 'action';
}

4. הרשאות ברמת אובייקט

<?php
// Fine-grained control for specific items

class Item extends XoopsObject
{
    /**
     * Check if user can view this item
     */
    public function canView(User $user): bool
    {
        // Public items anyone can view
        if ($this->getVar('status') === 'published') {
            return true;
        }

        // Owner can always view their items
        if ($this->getVar('user_id') === $user->getId()) {
            return true;
        }

        // Check group permissions
        $permChecker = xoops_getActiveModule()->getPermissionChecker();
        return $permChecker->hasPermission(
            $user,
            'item_view',
            $this->getVar('id')
        );
    }

    public function canEdit(User $user): bool
    {
        // Owner can edit their items
        if ($this->getVar('user_id') === $user->getId()) {
            return $permChecker->hasPermission($user, 'item_edit', $this->getVar('id'));
        }

        // Check if user can edit all items
        return $permChecker->hasPermission($user, 'item_edit_all', $this->getVar('id'));
    }

    public function canDelete(User $user): bool
    {
        return $permChecker->hasPermission($user, 'item_delete', $this->getVar('id'));
    }
}

5. שימוש בבקרים

<?php
// Example: Article controller

class ArticleController
{
    private PermissionChecker $permChecker;

    public function view(int $id, User $user): Response
    {
        $article = $this->repository->find($id);

        // Check permission
        if (!$article->canView($user)) {
            throw new AccessDeniedException('Cannot view this article');
        }

        return new HtmlResponse($this->renderArticle($article));
    }

    public function edit(int $id, User $user): Response
    {
        $article = $this->repository->find($id);

        // Check permission
        if (!$article->canEdit($user)) {
            throw new AccessDeniedException('Cannot edit this article');
        }

        // Handle form submission
        if ($this->request->isMethod('POST')) {
            $article->setVar('title', $this->request->getPost('title'));
            $article->setVar('content', $this->request->getPost('content'));
            $this->repository->insert($article);

            $this->auditLog('ARTICLE_EDITED', ['id' => $id, 'user_id' => $user->getId()]);

            // Invalidate permission cache
            $this->permChecker->clearCache($user->getId());

            return new RedirectResponse('/article/' . $id);
        }

        return new HtmlResponse($this->renderForm($article));
    }

    public function delete(int $id, User $user): Response
    {
        $article = $this->repository->find($id);

        if (!$article->canDelete($user)) {
            throw new AccessDeniedException('Cannot delete this article');
        }

        $this->repository->delete($article);

        $this->auditLog('ARTICLE_DELETED', ['id' => $id, 'user_id' => $user->getId()]);

        // Invalidate cache
        $this->permChecker->clearCache($user->getId());

        return new JsonResponse(['success' => true]);
    }
}

---

השלכות

השפעות חיוביות

1. בקרה גרעינית - ניהול הרשאות מכוון
2. סטנדרטי - עקבי בין המודולים
3. Cached - ביצועים משופרים עם שמירה בcache
4. ניתן לביקורת - עקוב אחר מי שינה מה
5. גמיש - תמיכה בהרשאות מותאמות אישית
6. ניתן להרחבה - מטפל בהיררכיות הרשאות מורכבות
7. ניתן לבדיקה - קל לבדיקת יחידה

אפקטים שליליים

1. מורכבות - עוד קוד לניהול
2. תקרת מסד נתונים - עוד טבלאות והצטרפות
3. אי תוקף cache - יש לנקות את הcache בשינויים
4. עקומת למידה - על המפתחים להבין מערכת
5. ביצועים - אם הcache אינו מוגדר כהלכה

סיכונים והפחתות

סיכון	חומרה	הקלה
הרשאות מורכבות מדי	בינוני	ברירות מחדל טובות, תיעוד
cache נתונים מיושנים	גבוה	TTL, ביטול חכם
רגרסיה של ביצועים	בינוני	Benchmark, אופטימיזציה של שאילתות
עוקף הרשאה	גבוה	ביקורת אבטחה, בדיקות

---

דפוסי עיצוב הרשאות

דפוס 1: הרשאות מבוססות בעלים

<?php
// User can edit their own items but not others'

public function canEdit(User $user): bool
{
    // Owner can always edit
    if ($this->isOwner($user)) {
        return true;
    }

    // Check group permissions for editing others' items
    return $this->permChecker->hasPermission($user, 'edit_all_items');
}

private function isOwner(User $user): bool
{
    return $this->getVar('user_id') === $user->getId();
}

דפוס 2: הרשאות מבוססות סטטוס

<?php
// Different permissions based on status

public function canView(User $user): bool
{
    switch ($this->getVar('status')) {
        case 'published':
            // Anyone with module permission can view
            return $this->permChecker->hasPermission($user, 'item_view');

        case 'draft':
            // Only owner or admin can view
            return $this->isOwner($user) ||
                   $this->permChecker->hasPermission($user, 'admin_manage');

        case 'archived':
            // Only admin can view
            return $this->permChecker->hasPermission($user, 'admin_manage');

        default:
            return false;
    }
}

דפוס 3: הרשאות מבוססות תפקידים

<?php
// Check against specific roles

public function hasAdminRole(User $user): bool
{
    return $user->getGroups()->contains('admin_group');
}

public function hasModeratorRole(User $user): bool
{
    return $user->getGroups()->contains('moderator_group') ||
           $this->hasAdminRole($user);
}

public function canModerate(User $user): bool
{
    return $this->hasModeratorRole($user);
}

---

החלטות קשורות

• ADR-001: ארכיטקטורה מודולרית - מודולים מגדירים הרשאות
• ADR-004: מערכת אבטחה - יסוד לאבטחה
• ADR-005: תוכנת אמצעית - יכולה לאכוף הרשאות

---

הפניות

מודלים של הרשאות

• RBAC (בקרת גישה מבוססת תפקידים)
• ABAC (בקרת גישה מבוססת תכונות)
• ACL (רשימת בקרת גישה)

יישום

• Symfony Security
• הרשאת Laravel

---

רשימת רשימת יישום

• הגדר רמות הרשאה סטנדרטיות
• צור מחלקה PermissionChecker
• יישם אסטרטגיית cache
• הוסף רישום ביקורת
• צור פונקציות עוזר
• כתוב מבחנים מקיפים
• מסמך למפתחים
• עדכן את כל המודולים
• מיטוב ביצועים
• סקירת אבטחה

---

היסטוריית גרסאות

גרסה	תאריך	שינויים
1.0.0	2024-01-28	מסמך ראשוני

---

#xoops #adr #permissions #autorization #rbac #security