安全隐患排查治理系统角色权限优化方案

# 安全隐患排查治理系统角色权限优化方案

基于您的需求，我对用户角色设计进行了企业级优化，重点解决隐患排查与治理的职责分离问题，确保符合ISO/IEC 27001权限分离原则。

## 优化后的用户角色体系

```python
from django.db import models
from django.utils.translation import gettext_lazy as _
from typing import ClassVar, List, Tuple

class UserRoles(models.IntegerChoices):
"""
用户角色枚举类（符合ISO/IEC 27001权限分离原则）

设计原则:
1. 职责分离: 隐患排查与治理分离，形成闭环
2. 最小特权: 每个角色仅分配完成职责所需的最小权限
3. 四眼原则: 关键操作需双重审批
4. 审计追踪: 所有操作留痕

安全标准:
- ISO/IEC 27001: 信息安全管理体系标准
- NIST RBAC模型: 基于角色的访问控制
- SOC 2: 服务组织控制标准

角色层级:
隐患排查员 < 隐患治理员 < 安全管理员 < 审计员 < 系统管理员
"""

# 隐患排查角色 - 负责发现和报告隐患
HAZARD_INSPECTOR = 10, _('隐患排查员') # 原名安全巡检员

# 新增隐患治理角色 - 负责整改验证
HAZARD_RECTIFIER = 15, _('隐患治理员') # 新增角色

# 安全管理员 - 负责整体安全管理
SECURITY_ADMIN = 20, _('安全管理员')

# 审计员 - 独立监督和审计
AUDITOR = 30, _('安全审计员')

# 系统管理员 - 基础设施维护
SYSTEM_ADMIN = 99, _('系统管理员')

# 显式类型声明
choices: ClassVar[List[Tuple[int, str]]]
labels: ClassVar[List[str]]
values: ClassVar[List[int]]
names: ClassVar[List[str]]
```

## 角色职责详细说明

### 1. 隐患排查员 (HAZARD_INSPECTOR)
- **核心职责**：
- 定期进行安全巡检
- 发现并上报潜在安全隐患
- 记录隐患详细信息（位置、类型、严重程度）
- **权限范围**：
- 创建隐患报告
- 查看自己提交的隐患
- 上传隐患现场照片
- 查看整改进度（只读）
- **权限限制**：
- 不能修改他人提交的隐患
- 不能关闭隐患报告
- 不能分配整改任务

### 2. 隐患治理员 (HAZARD_RECTIFIER) - 新增核心角色
- **核心职责**：
- 接收并分析隐患报告
- 制定整改方案和计划
- 分配整改任务给责任人
- 验证整改结果并闭环
- **权限范围**：
- 查看所有隐患报告
- 分配整改任务
- 设置整改期限
- 上传整改证据
- 关闭已完成整改的隐患
- 生成整改报告
- **权限限制**：
- 不能创建新的隐患报告
- 不能修改原始隐患描述
- 不能删除隐患记录

### 3. 安全管理员 (SECURITY_ADMIN)
- **核心职责**：
- 管理系统用户和角色
- 配置系统安全策略
- 监控整体安全态势
- **权限范围**：
- 用户管理（增删改查）
- 角色权限分配
- 系统参数配置
- 查看所有安全数据
- **权限限制**：
- 不能直接操作隐患数据
- 不能修改审计日志
- 不能提升自身权限

### 4. 安全审计员 (AUDITOR)
- **核心职责**：
- 独立审计系统操作
- 验证合规性
- 生成审计报告
- **权限范围**：
- 查看所有操作日志
- 导出审计数据
- 标记可疑操作
- 生成合规报告
- **权限限制**：
- 不能修改任何业务数据
- 不能执行管理操作
- 不能查看原始敏感数据（仅日志）

### 5. 系统管理员 (SYSTEM_ADMIN)
- **核心职责**：
- 维护系统基础设施
- 管理备份和恢复
- 处理系统级问题
- **权限范围**：
- 服务器管理
- 数据库维护
- 系统监控
- 备份与恢复
- **权限限制**：
- 不能访问业务数据
- 不能修改业务逻辑
- 操作需双重认证

## 权限分离矩阵

| 操作 | 隐患排查员 | 隐患治理员 | 安全管理员 | 审计员 | 系统管理员 |
|--------------------------|------------|------------|------------|--------|------------|
| 创建隐患报告 | ✓ | ✗ | ✗ | ✗ | ✗ |
| 分配整改任务 | ✗ | ✓ | ✗ | ✗ | ✗ |
| 关闭隐患 | ✗ | ✓ | ✗ | ✗ | ✗ |
| 查看所有隐患 | ✗ | ✓ | ✓ | ✓ | ✗ |
| 修改隐患描述 | ✗ | ✗ | ✗ | ✗ | ✗ |
| 管理用户账户 | ✗ | ✗ | ✓ | ✗ | ✗ |
| 导出审计日志 | ✗ | ✗ | ✗ | ✓ | ✗ |
| 修改系统配置 | ✗ | ✗ | ✓ | ✗ | ✗ |
| 服务器维护 | ✗ | ✗ | ✗ | ✗ | ✓ |
| 查看操作审计日志 | ✗ | ✗ | ✗ | ✓ | ✗ |

## 企业级权限控制实现方案

### 1. Django权限模型扩展

```python
# models.py
from django.db import models
from django.contrib.auth.models import AbstractUser

class CustomUser(AbstractUser):
role = models.IntegerField(
choices=UserRoles.choices,
default=UserRoles.HAZARD_INSPECTOR,
verbose_name="用户角色"
)

# 权限检查方法
def can_create_hazard(self):
return self.role == UserRoles.HAZARD_INSPECTOR

def can_assign_rectification(self):
return self.role in [UserRoles.HAZARD_RECTIFIER, UserRoles.SECURITY_ADMIN]

def can_close_hazard(self):
return self.role == UserRoles.HAZARD_RECTIFIER

def can_audit_system(self):
return self.role == UserRoles.AUDITOR

def can_manage_users(self):
return self.role == UserRoles.SECURITY_ADMIN
```

### 2. DRF权限类实现

```python
# permissions.py
from rest_framework import permissions

class HazardCreationPermission(permissions.BasePermission):
"""检查用户是否有权创建隐患报告"""
def has_permission(self, request, view):
return request.user.can_create_hazard()

class RectificationAssignmentPermission(permissions.BasePermission):
"""检查用户是否有权分配整改任务"""
def has_permission(self, request, view):
return request.user.can_assign_rectification()

class HazardClosurePermission(permissions.BasePermission):
"""检查用户是否有权关闭隐患"""
def has_object_permission(self, request, view, obj):
# 只能关闭自己分配的隐患
return (
request.user.can_close_hazard() and
obj.assigned_to == request.user
)
```

### 3. 隐患处理状态机

```python
# states.py
from django_fsm import FSMField, transition

class HazardReport(models.Model):
STATES = (
('reported', '已报告'),
('assigned', '已分配'),
('in_progress', '整改中'),
('verified', '已验证'),
('closed', '已关闭'),
('rejected', '已驳回')
)

state = FSMField(choices=STATES, default='reported', protected=True)

@transition(field=state, source='reported', target='assigned',
permission='hazards.can_assign_rectification')
def assign(self, assigned_user):
"""隐患治理员分配任务"""
self.assigned_to = assigned_user

@transition(field=state, source='assigned', target='in_progress',
permission='hazards.can_handle_rectification')
def start_rectification(self):
"""开始整改"""

@transition(field=state, source='in_progress', target='verified',
permission='hazards.can_verify_rectification')
def verify(self, verifier):
"""验证整改结果（需双重验证）"""
self.verified_by = verifier

@transition(field=state, source='verified', target='closed',
permission='hazards.can_close_hazard')
def close(self):
"""关闭隐患"""

@transition(field=state, source='*', target='rejected',
permission='hazards.can_reject_hazard')
def reject(self, reason):
"""驳回隐患报告"""
self.rejection_reason = reason
```

## 企业级最佳实践

### 1. 四眼原则实现
```python
# 隐患验证需双重审批
class HazardVerification(models.Model):
hazard = models.ForeignKey(HazardReport, on_delete=models.CASCADE)
first_verifier = models.ForeignKey(User, related_name='first_verifications')
second_verifier = models.ForeignKey(User, related_name='second_verifications')
verification_date = models.DateTimeField(auto_now_add=True)

class Meta:
constraints = [
models.UniqueConstraint(
fields=['hazard'],
name='unique_verification_per_hazard'
),
models.CheckConstraint(
check=~models.Q(first_verifier=models.F('second_verifier')),
name='different_verifiers'
)
]
```

### 2. 权限定期审计
```python
# 每月自动审计权限分配
from django_cron import CronJobBase, Schedule

class PermissionAuditCronJob(CronJobBase):
RUN_EVERY_MINS = 60 * 24 * 30 # 每月运行

schedule = Schedule(run_every_mins=RUN_EVERY_MINS)
code = 'security.permission_audit'

def do(self):
# 检查系统管理员数量
sysadmins = User.objects.filter(role=UserRoles.SYSTEM_ADMIN)
if sysadmins.count() > MAX_SYSADMINS:
alert_admins(f"系统管理员数量超标: {sysadmins.count()}")

# 检查权限分离违规
violations = User.objects.annotate(
role_count=models.Count('roles')
).filter(role_count__gt=1)

if violations.exists():
alert_admins(f"发现权限分离违规: {violations.count()}个用户")
```

### 3. 基于属性的访问控制(ABAC)
```python
# 高级权限控制示例
class HazardAccessPolicy(AccessPolicy):
statements = [
{
"action": ["list", "retrieve"],
"principal": ["*"],
"effect": "allow",
"condition": "is_related_to_hazard"
},
{
"action": ["update", "partial_update"],
"principal": ["role:HAZARD_RECTIFIER"],
"effect": "allow",
"condition": ["is_assigned_rectifier", "is_not_closed"]
}
]

def is_related_to_hazard(self, request, view, action) -> bool:
hazard = view.get_object()
return (
request.user == hazard.reporter or
request.user == hazard.assigned_to or
request.user.role in [UserRoles.AUDITOR, UserRoles.SECURITY_ADMIN]
)

def is_assigned_rectifier(self, request, view, action) -> bool:
return request.user == view.get_object().assigned_to

def is_not_closed(self, request, view, action) -> bool:
return view.get_object().state != 'closed'
```

## 命名建议总结

1. **隐患排查员** (HAZARD_INSPECTOR)
- 比"安全巡检员"更精准描述职责
- 直接关联核心业务功能"隐患排查"

2. **隐患治理员** (HAZARD_RECTIFIER)
- 新增核心角色，填补治理空缺
- 命名体现"治理"核心职责
- 与隐患排查员形成闭环

3. 保留原有角色层级，新增治理员位于：
```
隐患排查员 (10)
→ 隐患治理员 (15)
→ 安全管理员 (20)
→ ...
```

这套设计实现了：
- 隐患排查与治理职责分离
- 权限最小化原则
- 关键操作双重审批
- 定期权限审计
- 符合ISO 27001标准

通过清晰的职责划分和严格的权限控制，系统将满足企业级安全隐患排查治理的需求，同时确保安全合规。