Web缓存投毒攻击 - 元素码农

发布时间: 2025-03-23 13:42

↑

# Web缓存投毒攻击

## 漏洞概述

Web缓存投毒(Web Cache Poisoning)是一种高级的Web安全漏洞，攻击者通过操纵Web缓存的行为，使得缓存服务器存储并向其他用户提供恶意内容，从而影响大量用户。这种攻击方式特别危险，因为一旦成功，影响范围可能涉及所有访问被污染缓存的用户。

## 漏洞原理

### 1. 缓存机制

```javascript
// 缓存配置示例
const cacheConfig = {
    // 缓存键生成
    getCacheKey: (req) => {
        // 不安全的缓存键生成
        return req.url + req.headers['host'];
    },
    
    // 缓存规则
    shouldCache: (req) => {
        return req.method === 'GET';
    },
    
    // 缓存时间
    maxAge: 3600
};
```

### 2. 常见场景

```python
# 不安全的缓存实现
class CacheManager:
    def __init__(self):
        self.cache = {}
    
    def get_cache_key(self, request):
        # 漏洞：使用不可信的请求头
        return f"{request.path}_{request.headers.get('x-forwarded-host', '')}"
    
    def get_cached_response(self, request):
        cache_key = self.get_cache_key(request)
        return self.cache.get(cache_key)
    
    def set_cached_response(self, request, response):
        cache_key = self.get_cache_key(request)
        self.cache[cache_key] = response
```

### 3. 漏洞类型

```javascript
// 1. 请求头投毒
class HeaderPoisoning {
    constructor() {
        this.vulnerableHeaders = [
            'X-Forwarded-Host',
            'X-Host',
            'X-Forwarded-Server',
            'X-HTTP-Host-Override'
        ];
    }
    
    demonstrateAttack() {
        const payload = {
            url: 'https://example.com/api/data',
            headers: {
                'X-Forwarded-Host': 'evil.com',
                'Host': 'example.com'
            }
        };
        return payload;
    }
}

// 2. 参数投毒
class ParameterPoisoning {
    constructor() {
        this.vulnerableParams = [
            'callback',
            'jsonp',
            'template',
            'redirect'
        ];
    }
    
    demonstrateAttack() {
        const payload = {
            url: 'https://example.com/api/data',
            params: {
                'callback': 'alert(1);//'
            }
        };
        return payload;
    }
}
```

## 攻击技术

### 1. 基础攻击方式

```python
# Web缓存投毒攻击工具
class CachePoisoner:
    def __init__(self):
        self.techniques = [
            self.header_poisoning,
            self.param_poisoning,
            self.path_poisoning
        ]
    
    def header_poisoning(self, target):
        # 请求头投毒
        headers = {
            'X-Forwarded-Host': 'evil.com',
            'X-Forwarded-Scheme': 'http',
            'X-Original-URL': '/admin'
        }
        
        return self.send_request(target, headers=headers)
    
    def param_poisoning(self, target):
        # 参数投毒
        params = {
            'callback': 'alert(document.domain)',
            'template': '{{7*7}}',
            'redirect': 'javascript:alert(1)'
        }
        
        return self.send_request(target, params=params)
    
    def path_poisoning(self, target):
        # 路径投毒
        paths = [
            '/../../etc/passwd%00.css',
            '/.git/config',
            '/test.jpg/../../admin'
        ]
        
        return [self.send_request(f'{target}{path}') for path in paths]
```

### 2. 高级攻击技术

```javascript
// 高级缓存投毒技术
class AdvancedPoisoning {
    constructor() {
        this.techniques = {
            unkeyed: this.unkeyedHeaderAttack,
            multiStage: this.multiStageAttack,
            raceCondition: this.raceConditionAttack
        };
    }
    
    // 1. 未键控请求头攻击
    async unkeyedHeaderAttack(target) {
        const headers = [
            'X-Original-URL',
            'X-Rewrite-URL',
            'X-Override-URL',
            'X-Custom-IP-Authorization'
        ];
        
        const results = [];
        for (const header of headers) {
            const result = await this.testHeader(target, header);
            results.push(result);
        }
        
        return results;
    }
    
    // 2. 多阶段缓存投毒
    async multiStageAttack(target) {
        // 第一阶段：探测缓存行为
        const stage1 = await this.probeCacheBehavior(target);
        
        // 第二阶段：构造投毒载荷
        const stage2 = await this.craftPoisonPayload(stage1);
        
        // 第三阶段：执行投毒
        return await this.executePoisoning(stage2);
    }
    
    // 3. 竞态条件攻击
    async raceConditionAttack(target) {
        const requests = [];
        const poisonPayload = this.generatePoisonPayload();
        
        // 并发请求触发竞态条件
        for (let i = 0; i < 10; i++) {
            requests.push(
                this.sendRequest(target, poisonPayload)
            );
        }
        
        return Promise.all(requests);
    }
}
```

## 防护措施

### 1. 缓存配置

```javascript
// 安全的缓存配置实现
class SecureCacheConfig {
    constructor() {
        this.config = {
            // 安全的缓存键生成
            keyGenerator: (req) => {
                return this.generateSecureKey(req);
            },
            
            // 缓存规则
            cacheRules: {
                allowedMethods: ['GET'],
                allowedContentTypes: [
                    'text/html',
                    'application/json',
                    'text/css',
                    'application/javascript'
                ],
                maxAge: 3600
            },
            
            // 安全头部
            securityHeaders: {
                'Cache-Control': 'no-store, no-cache, must-revalidate',
                'Pragma': 'no-cache',
                'Expires': '0'
            }
        };
    }
    
    generateSecureKey(req) {
        // 只使用安全的请求属性
        const safeAttributes = {
            method: req.method,
            path: req.path,
            query: this.sanitizeQuery(req.query)
        };
        
        return crypto
            .createHash('sha256')
            .update(JSON.stringify(safeAttributes))
            .digest('hex');
    }
    
    sanitizeQuery(query) {
        // 过滤和验证查询参数
        const safeQuery = {};
        const allowedParams = new Set(['id', 'page', 'limit']);
        
        for (const [key, value] of Object.entries(query)) {
            if (allowedParams.has(key)) {
                safeQuery[key] = this.sanitizeValue(value);
            }
        }
        
        return safeQuery;
    }
}
```

### 2. 请求验证

```python
# 请求验证实现
class RequestValidator:
    def __init__(self):
        self.trusted_hosts = set([
            'example.com',
            'api.example.com',
            'static.example.com'
        ])
        
        self.trusted_schemes = set(['https'])
        
        self.sensitive_headers = set([
            'x-forwarded-host',
            'x-forwarded-scheme',
            'x-forwarded-proto'
        ])
    
    def validate_request(self, request):
        # 1. 验证Host头
        host = request.headers.get('host')
        if not self.is_trusted_host(host):
            return False
        
        # 2. 验证Scheme
        scheme = request.headers.get('x-forwarded-proto', 'https')
        if scheme not in self.trusted_schemes:
            return False
        
        # 3. 检查敏感头部
        for header in self.sensitive_headers:
            if header in request.headers:
                return False
        
        return True
    
    def is_trusted_host(self, host):
        if not host:
            return False
        
        host = host.lower().split(':')[0]
        return host in self.trusted_hosts
```

### 3. 响应处理

```java
// 响应处理实现
public class ResponseProcessor {
    private static final Set<String> NOCACHE_PATHS = new HashSet<>(Arrays.asList(
        "/admin",
        "/api/private",
        "/user/profile"
    ));
    
    public Response processResponse(Request request, Response response) {
        // 1. 检查路径
        if (shouldNotCache(request.getPath())) {
            return addNoCacheHeaders(response);
        }
        
        // 2. 验证内容
        if (!isValidContent(response)) {
            return addNoCacheHeaders(response);
        }
        
        // 3. 添加安全头部
        return addSecurityHeaders(response);
    }
    
    private boolean shouldNotCache(String path) {
        return NOCACHE_PATHS.stream()
            .anyMatch(prefix -> path.startsWith(prefix));
    }
    
    private boolean isValidContent(Response response) {
        String contentType = response.getHeader("Content-Type");
        return contentType != null && 
               !contentType.contains("text/html") &&
               !contentType.contains("application/json");
    }
    
    private Response addSecurityHeaders(Response response) {
        response.addHeader("Cache-Control", 
            "public, max-age=3600, must-revalidate");
        response.addHeader("Vary", "Accept-Encoding, User-Agent");
        response.addHeader("X-Content-Type-Options", "nosniff");
        return response;
    }
    
    private Response addNoCacheHeaders(Response response) {
        response.addHeader("Cache-Control", 
            "no-store, no-cache, must-revalidate");
        response.addHeader("Pragma", "no-cache");
        response.addHeader("Expires", "0");
        return response;
    }
}
```

## 最佳实践

### 1. 开发建议

1. 缓存策略
   - 谨慎选择缓存键
   - 验证缓存内容
   - 设置合理过期时间
   - 实施分层缓存

2. 请求处理
   - 验证请求来源
   - 过滤不安全头部
   - 规范化请求参数
   - 记录异常请求

3. 响应处理
   - 添加安全头部
   - 控制缓存范围
   - 验证响应内容
   - 监控缓存状态

### 2. 运维建议

1. 缓存配置
   - 合理的缓存策略
   - 定期清理缓存
   - 监控缓存使用
   - 备份重要数据

2. 安全监控
   - 实时监控告警
   - 异常行为检测
   - 访问日志分析
   - 性能指标监控

3. 应急响应
   - 快速清理缓存
   - 阻断异常请求
   - 恢复正常服务
   - 事件分析总结

### 3. 安全加固

1. 网络层面
   - 部署WAF防护
   - 配置访问控制
   - 启用HTTPS加密
   - 限制请求频率

2. 应用层面
   - 实施内容验证
   - 控制缓存策略
   - 规范化处理
   - 安全编码实践

3. 运维层面
   - 定期安全评估
   - 更新安全策略
   - 培训技术团队
   - 完善应急预案

## 总结

Web缓存投毒防护需要多层次防御：

1. 技术层面
   - 安全的缓存配置
   - 严格的请求验证
   - 规范的响应处理