RBAC 设计最佳实践#

// 过度依赖超级管理员角色
public class SecurityService {
    
    @PreAuthorize("hasRole('ADMIN')")
    public void deleteUser(Long userId) {
        // 任何管理员都可以删除任何用户
        userRepository.deleteById(userId);
    }
    
    @PreAuthorize("hasRole('ADMIN')")
    public void accessAllData() {
        // 管理员可以访问所有数据
        return dataRepository.findAll();
    }
    
    @PreAuthorize("hasRole('ADMIN')")
    public void modifySystemConfig() {
        // 管理员可以修改系统配置
        configRepository.updateAll(settings);
    }
}

public class SecurityService {
    
    // 用户管理：HR 管理员
    @PreAuthorize("hasRole('HR_ADMIN')")
    public void deleteUser(Long userId) {
        userRepository.deleteById(userId);
    }
    
    // 数据访问：数据分析师
    @PreAuthorize("hasRole('DATA_ANALYST') and hasAuthority('DATA:READ')")
    public List<Data> accessSalesData() {
        return dataRepository.findByDomain(Domain.SALES);
    }
    
    // 系统配置：运维管理员
    @PreAuthorize("hasRole('OPS_ADMIN') and hasAuthority('CONFIG:WRITE')")
    public void modifySystemConfig(SystemSettings settings) {
        configRepository.updateSystem(settings);
    }
}

public class DynamicRoleComposer {
    
    /**
     * 动态生成角色权限
     * 基于用户属性组合权限
     */
    public Set<Permission> composePermissions(User user) {
        Set<Permission> permissions = new HashSet<>();
        
        // 基础职能权限
        permissions.addAll(getBaseFunctionPermissions(user.getFunction()));
        
        // 业务域权限（只包含用户相关的域）
        permissions.addAll(
            getBusinessDomainPermissions(user.getAssignedDomains())
        );
        
        // 环境权限（基于当前环境）
        permissions.addAll(
            getEnvironmentPermissions(user.getCurrentEnvironment())
        );
        
        // 特殊情况：紧急权限
        if (user.hasEmergencyAccess()) {
            permissions.addAll(getEmergencyPermissions());
        }
        
        return permissions;
    }
}

public class RoleNamingConvention {
    
    /**
     * 角色命名格式：[类型]_[职能]_[范围]_[级别]
     */
    
    // 用户管理类
    // USER_VIEWER: 用户查看权限
    // USER_EDITOR: 用户编辑权限
    // USER_ADMIN: 用户管理权限
    
    // 数据访问类
    // DATA_READER: 数据读取
    // DATA_WRITER: 数据写入
    // DATA_ADMIN: 数据管理
    
    // 系统操作类
    // SYS_CONFIG: 系统配置
    // SYS_AUDIT: 审计查看
    // SYS_ADMIN: 系统管理
    
    // 业务操作类
    // ORDER_CREATE: 创建订单
    // ORDER_APPROVE: 审批订单
    // ORDER_CANCEL: 取消订单
}

public class SeparationOfDutyConfig {
    
    private static final List<MutexGroup> MUTEX_GROUPS = List.of(
        // 交易相关：请求者不能审批
        new MutexGroup("TRADE_SOD",
            Set.of("TRADE_CREATOR", "TRADE_APPROVER")),
        
        // 财务相关：制单与审核分离
        new MutexGroup("FINANCE_SOD",
            Set.of("FINANCE_CREATOR", "FINANCE_APPROVER", "FINANCE_PAYER")),
        
        // 安全相关：安全管理员不能审计
        new MutexGroup("SECURITY_SOD",
            Set.of("SECURITY_ADMIN", "SECURITY_AUDITOR")),
        
        // IT 相关：开发者不能是发布审批者
        new MutexGroup("IT_SOD",
            Set.of("DEVELOPER", "DEPLOY_APPROVER"))
    );
    
    /**
     * 检查用户是否违反 SOD 约束
     */
    public SODViolation checkViolation(User user, Role newRole) {
        Set<Role> currentRoles = user.getAssignedRoles();
        
        for (MutexGroup group : MUTEX_GROUPS) {
            if (group.contains(newRole) && 
                group.hasOverlap(currentRoles)) {
                return new SODViolation(
                    group.getName(),
                    "角色 " + newRole.getName() + 
                    " 与已有角色存在职责冲突"
                );
            }
        }
        return SODViolation.NONE;
    }
}

@Service
public class PermissionMatrixService {
    
    /**
     * 角色权限矩阵
     * 维护角色与权限的映射关系
     */
    
    public PermissionMatrix buildMatrix() {
        List<Role> allRoles = roleRepository.findAllActive();
        List<Permission> allPermissions = permissionRepository.findAll();
        
        Map<Role, Set<Permission>> matrix = new HashMap<>();
        
        for (Role role : allRoles) {
            Set<Permission> permissions = role.getPermissions();
            matrix.put(role, permissions);
        }
        
        return new PermissionMatrix(allRoles, allPermissions, matrix);
    }
    
    /**
     * 检查权限覆盖
     * 确保每个权限都被至少一个角色覆盖
     */
    public List<Permission> findOrphanedPermissions() {
        Set<Permission> covered = roleRepository.findAll()
            .stream()
            .flatMap(r -> r.getPermissions().stream())
            .collect(Collectors.toSet());
        
        return permissionRepository.findAll().stream()
            .filter(p -> !covered.contains(p))
            .collect(Collectors.toList());
    }
    
    /**
     * 生成权限报告
     */
    public PermissionReport generateReport() {
        PermissionMatrix matrix = buildMatrix();
        
        return new PermissionReport(
            matrix.getTotalRoles(),
            matrix.getTotalPermissions(),
            matrix.getPermissionsPerRole(),
            findOrphanedPermissions(),
            findOverprivilegedRoles(),
            findUnderprivilegedRoles()
        );
    }
}

public class LeastPrivilegeChecker {
    
    /**
     * 分析用户实际使用的权限
     * 与授予权限对比，发现过度授权
     */
    public PrivilegeAnalysis analyzeUserPrivileges(Long userId) {
        User user = userRepository.findById(userId);
        
        // 授予的权限（含角色继承）
        Set<Permission> granted = permissionService
            .getUserEffectivePermissions(userId);
        
        // 实际使用的权限（基于审计日志）
        Set<Permission> used = auditLogRepository
            .findDistinctPermissionsByUser(userId, 
                Duration.ofDays(90));
        
        // 分析差异
        Set<Permission> unused = Sets.difference(granted, used);
        Set<Permission> undocumented = Sets.difference(used, granted);
        
        return new PrivilegeAnalysis(
            user.getUsername(),
            granted.size(),
            used.size(),
            unused,
            undocumented,
            calculateOverPrivilegedScore(granted, used)
        );
    }
    
    /**
     * 定期生成最小权限报告
     */
    @Scheduled(cron = "0 0 2 * * ?") // 每天凌晨 2 点
    public void generateLeastPrivilegeReport() {
        List<PrivilegeAnalysis> analyses = userRepository.findAll()
            .stream()
            .map(u -> analyzeUserPrivileges(u.getId()))
            .filter(a -> a.getOverprivilegedScore() > 0.3)
            .sorted(Comparator.comparing(
                PrivilegeAnalysis::getOverprivilegedScore).reversed())
            .collect(Collectors.toList());
        
        if (!analyses.isEmpty()) {
            emailService.sendReport(
                "Security Team",
                "最小权限分析报告",
                analyses
            );
        }
    }
}