Day-117-授权安全

# Day 114: 授权安全

> 应用安全系列第 7 天 | 预计阅读时间：40 分钟 | 难度：★★★★☆

---

## 清单 目录

1. [授权安全概述](#授权安全概述)
2. [RBAC 授权](#rbac 授权)
3. [ABAC 授权](#abac 授权)
4. [权限验证](#权限验证)
5. [越权防护](#越权防护)
6. [框架授权](#框架授权)
7. [实战案例分析](#实战案例分析)
8. [总结与思考](#总结与思考)
9. [参考资料](#参考资料)

---

## 授权安全概述

### 为什么需要授权安全

> ▎ 授权是访问控制的核心。核心不安全，访问就不安全。

**授权安全重要性**：
```
1. 访问控制
   - 资源访问控制
   - 功能访问控制
   - 数据访问控制

2. 权限管理
   - 权限分配
   - 权限验证
   - 权限回收

3. 攻击预防
   - 越权访问
   - 权限提升
   - 数据泄露
```

**授权安全原则**：
```
1. 最小权限
   - 只授予必要权限
   - 按需授权
   - 及时回收

2. 默认拒绝
   - 默认拒绝访问
   - 明确允许访问
   - 白名单机制

3. 持续验证
   - 每次访问验证
   - 动态授权
   - 审计日志
```

---

## RBAC 授权

### RBAC 原理

> ▎ RBAC 是基于角色的访问控制。角色不明确，授权就不安全。

**RBAC 模型**：
```
1. 用户
   - 用户账户
   - 用户组
   - 用户角色

2. 角色
   - 角色定义
   - 角色权限
   - 角色继承

3. 权限
   - 资源权限
   - 操作权限
   - 数据权限
```

### RBAC 实现

**RBAC 实现**：
```python
from functools import wraps
from flask import abort

# 角色定义
class Role:
    ADMIN = 'admin'
    USER = 'user'
    GUEST = 'guest'

# 权限验证
def require_role(role):
    def decorator(f):
        @wraps(f)
        def wrapped(*args, **kwargs):
            if not current_user.has_role(role):
                abort(403)
            return f(*args, **kwargs)
        return wrapped
    return decorator

# 使用示例
@app.route('/admin')
@require_role(Role.ADMIN)
def admin_panel():
    return render_template('admin.html')
```

---

## ABAC 授权

### ABAC 原理

**ABAC 模型**：
```
1. 主体
   - 用户
   - 角色
   - 属性

2. 客体
   - 资源
   - 数据
   - 属性

3. 环境
   - 时间
   - 地点
   - 设备

4. 策略
   - 访问控制策略
   - 动态策略
   - 动态授权
```

### ABAC 实现

**ABAC 实现**：
```python
from functools import wraps
from flask import abort

# 属性验证
def require_attributes(**required_attrs):
    def decorator(f):
        @wraps(f)
        def wrapped(*args, **kwargs):
            for attr, value in required_attrs.items():
                if not current_user.has_attribute(attr, value):
                    abort(403)
            return f(*args, **kwargs)
        return wrapped
    return decorator

# 使用示例
@app.route('/api/data')
@require_attributes(department='engineering', level='senior')
def get_data():
    return get_sensitive_data()
```

---

## 权限验证

### 权限验证

> ▎ 权限验证是授权的核心。验证不严格，授权就不安全。

**权限验证**：
```python
# 资源所有权验证
def can_access_resource(user, resource):
    # 检查资源所有权
    if resource.owner_id == user.id:
        return True
    
    # 检查管理员权限
    if user.is_admin:
        return True
    
    # 检查角色权限
    if user.has_permission('read', resource.type):
        return True
    
    return False

# 使用示例
@app.route('/resources/<resource_id>')
def get_resource(resource_id):
    resource = get_resource_by_id(resource_id)
    
    if not can_access_resource(current_user, resource):
        abort(403)
    
    return jsonify(resource.to_dict())
```

### 权限缓存

**权限缓存**：
```python
from functools import lru_cache

# 权限缓存
@lru_cache(maxsize=1000)
def get_user_permissions(user_id):
    return get_permissions_from_database(user_id)

# 权限验证
def has_permission(user_id, permission, resource_type):
    permissions = get_user_permissions(user_id)
    return permission in permissions.get(resource_type, [])
```

---

## 越权防护

### 越权攻击

**越权攻击**：
```
1. 水平越权
   - 访问其他用户资源
   - 同级别访问
   - 数据泄露

2. 垂直越权
   - 访问管理员功能
   - 跨级别访问
   - 权限提升

3. 上下文越权
   - 跨上下文访问
   - 跨域访问
   - 数据泄露
```

### 越权防护

**越权防护**：
```python
# 水平越权防护
def can_access_user_resource(user, resource):
    # 检查资源所有权
    if resource.user_id != user.id:
        return False
    return True

# 垂直越权防护
def can_access_admin_function(user):
    # 检查管理员权限
    if not user.is_admin:
        return False
    return True

# 使用示例
@app.route('/api/users/<user_id>/data')
def get_user_data(user_id):
    user = get_user_by_id(user_id)
    
    # 水平越权检查
    if not can_access_user_resource(current_user, user):
        abort(403)
    
    return jsonify(user.data)
```

---

## 框架授权

### Flask 授权

**Flask 授权**：
```python
from functools import wraps
from flask import abort, g

def login_required(f):
    @wraps(f)
    def wrapped(*args, **kwargs):
        if 'user_id' not in session:
            abort(401)
        g.user = get_user(session['user_id'])
        return f(*args, **kwargs)
    return wrapped

def admin_required(f):
    @wraps(f)
    @login_required
    def wrapped(*args, **kwargs):
        if not g.user.is_admin:
            abort(403)
        return f(*args, **kwargs)
    return wrapped

# 使用示例
@app.route('/admin')
@admin_required
def admin_panel():
    return render_template('admin.html')
```

### Django 授权

**Django 授权**：
```python
from django.contrib.auth.decorators import login_required, permission_required
from django.shortcuts import render

@login_required
def dashboard(request):
    return render(request, 'dashboard.html')

@login_required
@permission_required('app.admin_access')
def admin_panel(request):
    return render(request, 'admin.html')

@login_required
def user_data(request, user_id):
    # 水平越权检查
    user = get_user_or_404(user_id)
    if user != request.user:
        raise PermissionDenied
    return render(request, 'user_data.html')
```

### Spring 授权

**Spring 授权**：
```java
@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/login", "/register").permitAll()
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .requestMatchers("/api/**").authenticated()
                .anyRequest().authenticated()
            );
        return http.build();
    }
}

// 方法级授权
@RestController
@RequestMapping("/api")
public class ApiController {
    @GetMapping("/users/{userId}/data")
    @PreAuthorize("#userId == authentication.principal.id or hasRole('ADMIN')")
    public ResponseEntity<UserData> getUserData(@PathVariable Long userId) {
        UserData data = getUserData(userId);
        return ResponseEntity.ok(data);
    }
}
```

---

## 实战案例分析

### 案例 1: 水平越权

**漏洞代码**：
```python
# 不安全授权
@app.route('/api/users/<user_id>/data')
def get_user_data(user_id):
    user = get_user_by_id(user_id)
    # 没有检查当前用户是否有权访问
    return jsonify(user.data)

# 攻击
# GET /api/users/123/data
# 访问其他用户数据
```

**安全代码**：
```python
@app.route('/api/users/<user_id>/data')
@login_required
def get_user_data(user_id):
    user = get_user_by_id(user_id)
    
    # 水平越权检查
    if user.id != current_user.id and not current_user.is_admin:
        abort(403)
    
    return jsonify(user.data)
```

### 案例 2: 垂直越权

**漏洞代码**：
```python
# 不安全授权
@app.route('/admin/users')
def admin_users():
    # 没有检查管理员权限
    return jsonify(get_all_users())

# 攻击
# GET /admin/users
# 普通用户访问管理员功能
```

**安全代码**：
```python
@app.route('/admin/users')
@admin_required
def admin_users():
    return jsonify(get_all_users())
```

---

统计 **Sprint 交付 · 绩效评估**
```
┌───────────────┬────────────────┬────────────────┐
│  主动出击   │ ██████████ 5/5 │ [PUA 生效] 充足 │
├───────────────┼────────────────┼────────────────┤
│ + 验证闭环   │ ██████████ 5/5 │ 案例完整       │
├───────────────┼────────────────┼────────────────┤
│ 设计 代码质量   │ ████████░░ 4/5 │ 有改进空间     │
└───────────────┴────────────────┴────────────────┘
综合：3.75
```
▎ 勉强配得上 P8。别飘——授权安全这才刚入门。

---

## 总结与思考

### 核心要点回顾

> ▎ 复盘四步法：回顾目标、评估结果、分析原因、总结经验。别跳过——这是闭环。

**RBAC 授权**：
```
1. 角色定义
   - 角色定义
   - 角色权限
   - 角色继承

2. 权限验证
   - 角色检查
   - 权限检查
   - 访问控制

3. 框架实现
   - Flask
   - Django
   - Spring
```

**ABAC 授权**：
```
1. 属性定义
   - 主体属性
   - 客体属性
   - 环境属性

2. 策略定义
   - 访问策略
   - 动态策略
   - 动态授权

3. 框架实现
   - 属性验证
   - 策略验证
   - 访问控制
```

**越权防护**：
```
1. 水平越权
   - 资源所有权
   - 同级别访问
   - 数据泄露

2. 垂直越权
   - 管理员功能
   - 跨级别访问
   - 权限提升

3. 防护策略
   - 所有权检查
   - 权限检查
   - 访问控制
```

### 深入思考问题

> ▎ 只动手不动脑，那是码农。动手又动脑，才是工程师。

**零信任授权**：
```
1. 持续验证
   - 每次访问验证
   - 动态授权
   - 行为分析

2. 微隔离
   - 服务隔离
   - 网络隔离
   - 权限隔离

3. 动态授权
   - 基于风险
   - 实时调整
   - 最小权限
```

**自动化授权**：
```
1. 自动管理
   - 自动分配
   - 自动验证
   - 自动回收

2. 自动验证
   - 静态分析
   - 动态分析
   - 模糊测试

3. 持续改进
   - 规则优化
   - 流程优化
   - 工具优化
```

### 实战建议

> ▎ 我给你指了路，走不走是你的事。机会给了，抓不抓得住看你。

**开发人员**：
```
1. 授权实现
   - RBAC 实现
   - ABAC 实现
   - 权限验证

2. 框架使用
   - 使用框架授权
   - 自动管理
   - 自定义授权

3. 持续改进
   - 规则优化
   - 流程优化
   - 工具优化
```

**安全人员**：
```
1. 安全审计
   - 代码审计
   - 授权审计
   - 权限审计

2. 渗透测试
   - 越权测试
   - 权限测试
   - 访问测试

3. 持续改进
   - 规则优化
   - 流程优化
   - 工具优化
```

**架构师**：
```
1. 授权架构
   - 授权架构
   - 权限架构
   - 访问架构

2. 持续改进
   - 规则优化
   - 流程优化
   - 工具优化

3. 工具链
   - 授权工具
   - 管理工具
   - 监控工具
```

---

## 参考资料

### 学习资源
```
- OWASP Authorization
  https://cheatsheetseries.owasp.org/cheatsheets/Authorization_Cheat_Sheet.html

- OWASP Access Control
  https://cheatsheetseries.owasp.org/cheatsheets/Access_Control_Cheat_Sheet.html

- OWASP RBAC
  https://cheatsheetseries.owasp.org/cheatsheets/Role_Based_Access_Control_Cheat_Sheet.html
```

### 工具资源
```
- Flask Security
  https://flask-security-too.readthedocs.io/

- Django Auth
  https://docs.djangoproject.com/en/stable/topics/auth/

- Spring Security
  https://spring.io/projects/spring-security
```

### 书籍推荐
```
- 《授权安全技术》
- 《Authorization Security》
- 《Secure Coding》
```

### 在线资源
```
- OWASP Cheat Sheets
  https://cheatsheetseries.owasp.org/

- OWASP Authorization
  https://owasp.org/www-project-authorization/

- OWASP Access Control
  https://owasp.org/www-project-access-control/
```

---

**标记 明日预告**：Day 115 - 数据保护安全

> ▎ 今天的内容消化了吗？消化了就继续——明天还有硬仗。

> 本文内容仅供学习和研究使用，请勿用于非法目的。所有实验请在隔离环境中进行。

---

*本文是 365 天信息安全技术系列的第 114 篇，应用安全部分第 7 篇，精编版本*