面试题集锦:安全基础补强

通识对照:游客设备指纹要分层:信号不是身份证

面试题集锦:安全基础补强

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。


正文

Interview Focus: 大型加密货币交易所 Senior Backend Developer — Risk Domain Tags: OWASP Top 10, SQL Injection, XSS, CSRF, SSRF, OAuth2, JWT, API Key, Replay Attack, Data Masking, Spring Security


TL;DR

Web 安全的核心是信任边界的构建与校验——从输入层(防注入/XSS)、传输层(HTTPS/TLS)、会话层(JWT/OAuth2/API Key)到存储层(敏感数据加密/脱敏),每一层都必须在"假设外部不可信"的前提下做防御。对于加密货币交易所而言,安全不仅是合规要求,更是生死线:一次 SQL 注入可能导致用户资产数据库泄露,一个 JWT 漏洞可能让攻击者直接操作用户钱包,一次成功的重放攻击可能让同一笔授权被多次执行提现。本文从 OWASP Top 10 出发,深入原理、提供生产级 Java 代码,并映射到 Crypto Risk 系统的实际场景。


1. 概念定义(是什么)

1.1 OWASP Top 10 核心威胁

威胁英文全称本质类比记忆
注入攻击Injection (SQL/NoSQL/OS/LDAP)将恶意代码注入到查询/命令中执行像给快递单上的"备注栏"写上"请转交给我邻居(其实是小偷)",分拣系统照做了
XSSCross-Site Scripting将恶意脚本注入到网页中,在用户浏览器执行像在图书馆的畅销书里夹了一张纸条,每个借书的人回家打开书都会看到并执行纸条上的指令
CSRFCross-Site Request Forgery诱导已登录用户在不知情的情况下执行非预期操作像偷偷把一封已经签好名的空白支票塞到别人的邮箱里,邮差(浏览器)自动帮你投递到银行
SSRFServer-Side Request Forgery让服务器发起攻击者控制的请求,访问内网/元数据像打电话到前台说"我是老板,把内部文件发到这个邮箱",前台因为信任内部来电照做了
Broken Authentication身份认证缺陷会话管理/凭证验证漏洞导致身份被冒用像用一张复印的员工卡刷开了公司所有的门禁
Sensitive Data Exposure敏感数据泄露未加密/脱敏存储或传输敏感信息像把保险箱密码写在便利贴上贴在保险箱门上
Broken Access Control访问控制失效未做权限校验或校验不当像酒店电梯没有房卡验证,任何人都能去总统套房楼层

类比:安全防御体系 = 中世纪城堡

  • 输入校验 = 护城河 + 吊桥(第一道防线,阻止敌人靠近城墙)
  • HTTPS/TLS = 信使的密语(即使信使被截获,敌人也看不懂内容)
  • JWT/OAuth2 = 贵族纹章(证明你是谁、来自哪个家族、有什么权限)
  • WAF/RBAC = 城墙上的守卫 + 城内分区(不同区域有不同准入级别)
  • 加密/脱敏 = 藏宝图的分割保存(即使攻破城堡,也找不到完整宝藏)

1.2 为什么安全在 Risk 系统中是生死线

在传统电商中,安全漏洞可能导致用户信息泄露或资金损失;在加密货币交易所中:

  1. 资产不可逆:区块链交易不可回滚,一次成功攻击 = 永久损失
  2. 高价值目标:交易所钱包常持有数十亿美金的资产,是 APT 攻击(Advanced Persistent Threat)的首要目标
  3. 合规高压:MiCA、FCA、MAS 等监管要求严格的 KYC/AML 数据保护,违规罚款可达全球营收的 4%
  4. API 高频交易:量化交易 API 的鉴权漏洞可能导致毫秒级的大量非法交易

2. 核心原理与图解

2.1 SQL 注入原理:从拼接到预编译的本质差异

漏洞模式:

// ❌ 危险:字符串拼接
String sql = "SELECT * FROM users WHERE username = '" + username + "' AND password = '" + password + "'";
// 输入: username = "admin' --"
// 结果: SELECT * FROM users WHERE username = 'admin' --' AND password = 'xxx'

预编译防御原理:

┌─────────────────────────────────────────────────────────────┐
│                    SQL 预编译执行流程                          │
├─────────────────────────────────────────────────────────────┤
│  1. Parse:  "SELECT * FROM users WHERE username = ?"        │
│            ↓  数据库解析 SQL 结构,生成执行计划                │
│  2. Compile:  编译为内部执行计划(与参数无关)                 │
│            ↓                                                │
│  3. Execute:  绑定参数 'admin' --' 作为纯字符串值             │
│               (不再被解析为 SQL 语法的一部分)                 │
└─────────────────────────────────────────────────────────────┘

关键洞察:预编译将"代码(SQL 结构)"与"数据(参数值)"在协议层面分离,即使参数中包含 SQL 关键字,也仅被当作字符串字面量处理。

2.2 XSS vs CSRF 的本质区别

维度XSSCSRF
攻击目标用户浏览器(客户端)Web 服务器(服务端)
利用机制注入脚本,窃取 Cookie/执行操作利用浏览器自动携带 Cookie 的机制
是否需要用户交互用户访问被注入页面即可用户需主动点击/加载恶意链接
防御核心输出编码(Output Encoding)Token 校验 + SameSite Cookie
类比在别人的信里夹带"看到此信后立即汇款"伪造一封带有真实签名的信件寄给银行

2.3 JWT 结构与安全边界

┌────────────────────────────────────────────────────────────────┐
│                        JWT Token 结构                           │
├────────────────────────────────────────────────────────────────┤
│  Header (Base64Url)                                            │
│  ─────────────────────                                         │
│  { "alg": "RS256", "typ": "JWT", "kid": "2024-01" }           │
│                                                                │
│  Payload (Base64Url) —— 不要放敏感信息!                         │
│  ─────────────────────                                         │
│  {                                                             │
│    "sub": "user_9527",        // 主题(用户ID)                 │
│    "iss": "大型加密货币交易所.com",      // 签发者                        │
│    "aud": "api.大型加密货币交易所.com",  // 受众                          │
│    "iat": 1704067200,         // 签发时间                      │
│    "exp": 1704070800,         // 过期时间(严格校验)            │
│    "jti": "uuid-v4",          // 唯一标识(用于防重放/黑名单)    │
│    "scope": "read:wallet withdraw:crypto",                    │
│    "mfa_verified": true       // 2FA 是否通过                   │
│  }                                                             │
│                                                                │
│  Signature (HMAC/RSA/ECDSA)                                    │
│  ─────────────────────                                         │
│  RSASHA256(                                                    │
│    base64Url(header) + "." + base64Url(payload),               │
│    private_key                                                 │
│  )                                                             │
└────────────────────────────────────────────────────────────────┘

关键安全原则:

  1. 密钥隔离:签名密钥(尤其是 RS256 的 private key)必须存储在 HSM/KMS 中,严禁硬编码
  2. 算法混淆防御(Alg=None Attack):服务端必须校验 alg 字段为预期算法,拒绝 none/null
  3. 密钥 ID 轮换:通过 kid 支持密钥平滑轮换,旧密钥签发的 Token 逐步失效
  4. 短有效期:Access Token 建议 15 分钟,配合 Refresh Token 机制

2.4 防重放攻击(Replay Attack)的三重校验

interview security fundamentals qa · 图 1
interview security fundamentals qa · 图 1 · 点击查看 SVG 原图

三重校验 = 时间窗口 + 幂等 nonce + 签名验证,缺一不可:

  • 没有时间窗口:攻击者可以无限期保存请求,在未来任意时间重放
  • 没有 nonce:在时间窗口内,完全相同的请求可以被重放多次
  • 没有签名:攻击者可以篡改请求体后重放

2.5 OAuth2.0 授权码流程(Authorization Code Flow with PKCE)

interview security fundamentals qa · 图 2
interview security fundamentals qa · 图 2 · 点击查看 SVG 原图

PKCE(Proof Key for Code Exchange)的作用:防止 authorization code 被截获后使用。即使攻击者窃取了 code,没有 code_verifier 也无法换取 Token。这是 OAuth2.0 公共客户端(移动端/SPA)的强制要求。


3. 语法详解与代码示例(怎么用)

3.1 SQL 注入防御:PreparedStatement + MyBatis ORM

3.1.1 JDBC PreparedStatement(底层原理)

package com.大型加密货币交易所.risk.security.sql;
 
import org.springframework.stereotype.Repository;
import javax.sql.DataSource;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
 
/**
 * 用户风控标签查询 Repository —— 使用预编译语句防御 SQL 注入
 * 场景:根据用户 ID 或邮箱查询其风险评分标签
 */
@Repository
public class UserRiskTagRepository {
 
    private final DataSource dataSource;
 
    public UserRiskTagRepository(DataSource dataSource) {
        this.dataSource = dataSource;
    }
 
    /**
     * 查询用户的风险标签列表
     * 防御点:使用 PreparedStatement,用户输入仅作为参数绑定
     */
    public List<RiskTag> findRiskTagsByUserCriteria(String userId, String emailPattern, int minRiskScore) {
        List<RiskTag> tags = new ArrayList<>();
 
        // 动态构建 WHERE 条件,但结构是固定的,仅参数是动态的
        StringBuilder sql = new StringBuilder(
            "SELECT user_id, tag_name, risk_score, created_at " +
            "FROM user_risk_tags WHERE 1=1 "
        );
        List<Object> params = new ArrayList<>();
 
        if (userId != null && !userId.isBlank()) {
            sql.append("AND user_id = ? ");
            params.add(userId);
        }
        if (emailPattern != null && !emailPattern.isBlank()) {
            // ❌ 危险:如果直接拼接 like '%{emailPattern}%'
            // ✅ 安全:预编译参数,即使 emailPattern = "%' OR '1'='1" 也只会被当作字符串
            sql.append("AND email LIKE ? ");
            params.add("%" + emailPattern + "%"); // 通配符在参数层面拼接
        }
        sql.append("AND risk_score >= ? ORDER BY created_at DESC");
        params.add(minRiskScore);
 
        try (Connection conn = dataSource.getConnection();
             PreparedStatement ps = conn.prepareStatement(sql.toString())) {
 
            // 参数绑定:索引从 1 开始
            for (int i = 0; i < params.size(); i++) {
                ps.setObject(i + 1, params.get(i));
            }
 
            try (ResultSet rs = ps.executeQuery()) {
                while (rs.next()) {
                    tags.add(new RiskTag(
                        rs.getString("user_id"),
                        rs.getString("tag_name"),
                        rs.getInt("risk_score"),
                        rs.getTimestamp("created_at")
                    ));
                }
            }
        } catch (SQLException e) {
            throw new RiskDataAccessException("Failed to query risk tags", e);
        }
        return tags;
    }
}

3.1.2 MyBatis ORM(参数化查询)

package com.大型加密货币交易所.risk.mapper;
 
import com.大型加密货币交易所.risk.entity.TransactionRiskLog;
import org.apache.ibatis.annotations.*;
import java.util.List;
 
/**
 * 交易风险日志 Mapper —— MyBatis #{} 自动使用 PreparedStatement
 */
@Mapper
public interface TransactionRiskLogMapper {
 
    /**
     * 根据交易哈希和币种查询风控拦截记录
     * #{} 是预编译参数,${} 是字符串替换(危险!)
     */
    @Select("SELECT id, tx_hash, symbol, amount, risk_level, blocked_reason, created_at " +
            "FROM tx_risk_logs " +
            "WHERE tx_hash = #{txHash} AND symbol = #{symbol} AND created_at > #{startTime}")
    List<TransactionRiskLog> findByTxHashAndSymbol(
        @Param("txHash") String txHash,
        @Param("symbol") String symbol,
        @Param("startTime") java.time.Instant startTime
    );
 
    /**
     * ⚠️ 危险示例:动态表名/列名必须使用 ${},但必须做白名单校验!
     */
    @Select("SELECT ${column} FROM ${table} WHERE user_id = #{userId}")
    List<String> findDynamicColumn(
        @Param("table") String table,
        @Param("column") String column,
        @Param("userId") Long userId
    );
}
package com.大型加密货币交易所.risk.service;
 
import org.springframework.stereotype.Service;
import java.util.Set;
 
/**
 * SQL 注入白名单校验服务 —— 当必须使用 ${} 时做防御
 */
@Service
public class SqlInjectionPreventionService {
 
    private static final Set<String> ALLOWED_TABLES = Set.of(
        "user_risk_tags", "tx_risk_logs", "withdraw_audit_logs", "kyc_verification_records"
    );
    private static final Set<String> ALLOWED_COLUMNS = Set.of(
        "user_id", "risk_score", "status", "created_at", "tx_hash"
    );
 
    public void validateTableName(String table) {
        if (!ALLOWED_TABLES.contains(table)) {
            throw new SecurityException("Illegal table name: " + table);
        }
    }
 
    public void validateColumnName(String column) {
        if (!ALLOWED_COLUMNS.contains(column)) {
            throw new SecurityException("Illegal column name: " + column);
        }
    }
}

3.2 XSS/CSRF/SSRF 防御过滤器

3.2.1 XSS 过滤器(请求体 + 请求参数清洗)

package com.大型加密货币交易所.risk.security.filter;
 
import jakarta.servlet.*;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletRequestWrapper;
import org.springframework.stereotype.Component;
import org.springframework.web.util.HtmlUtils;
 
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.*;
 
/**
 * XSS 防御过滤器 —— 对所有输入参数和 JSON 请求体进行 HTML 实体编码
 * 场景:用户提交的备注、KYC 文档名称、交易标签等字段可能包含恶意脚本
 */
@Component
public class XssFilter implements Filter {
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
 
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        // 跳过文件上传接口(二进制数据不需要也不应做 HTML 编码)
        if (isMultipartRequest(httpRequest)) {
            chain.doFilter(request, response);
            return;
        }
 
        XssHttpServletRequestWrapper wrappedRequest = new XssHttpServletRequestWrapper(httpRequest);
        chain.doFilter(wrappedRequest, response);
    }
 
    private boolean isMultipartRequest(HttpServletRequest request) {
        String contentType = request.getContentType();
        return contentType != null && contentType.toLowerCase().startsWith("multipart/");
    }
 
    /**
     * 包装器:对 getParameter/getHeader 返回的值做 HTML 转义
     */
    public static class XssHttpServletRequestWrapper extends HttpServletRequestWrapper {
 
        public XssHttpServletRequestWrapper(HttpServletRequest request) {
            super(request);
        }
 
        @Override
        public String getParameter(String name) {
            String value = super.getParameter(name);
            return encode(value);
        }
 
        @Override
        public String[] getParameterValues(String name) {
            String[] values = super.getParameterValues(name);
            if (values == null) return null;
            return Arrays.stream(values).map(this::encode).toArray(String[]::new);
        }
 
        @Override
        public String getHeader(String name) {
            String value = super.getHeader(name);
            return encode(value);
        }
 
        /**
         * 对 JSON 请求体做转义 —— 适用于 @RequestBody 的场景
         * 注意:更推荐在输出时做编码(Content Security Policy + 输出编码),
         * 输入时清洗会破坏合法内容(如用户想输入 <BTC> 标签)
         */
        @Override
        public ServletInputStream getInputStream() throws IOException {
            String body = readBody(super.getInputStream());
            // 生产环境中,建议对 JSON 值做语义化清洗而非全局替换
            // 这里使用 HtmlUtils 做基础演示,实际可替换为更精细的 DOMPurify-like 逻辑
            String sanitizedBody = sanitizeJson(body);
            byte[] bytes = sanitizedBody.getBytes(StandardCharsets.UTF_8);
 
            return new ServletInputStream() {
                private final ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
                @Override public int read() { return bais.read(); }
                @Override public boolean isFinished() { return bais.available() == 0; }
                @Override public boolean isReady() { return true; }
                @Override public void setReadListener(ReadListener listener) {}
            };
        }
 
        private String readBody(InputStream inputStream) throws IOException {
            return new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))
                    .lines().reduce("", String::concat);
        }
 
        private String sanitizeJson(String json) {
            // 生产级实现:使用正则或 JSON 解析器,仅对字符串值做编码
            // 简单示例:转义 <script> 标签
            return json.replaceAll("(?i)<script[^>]*>[\\s\\S]*?</script>", "")
                       .replaceAll("(?i)javascript:", "")
                       .replaceAll("(?i)on\\w+\\s*=", "");
        }
 
        private String encode(String value) {
            return value == null ? null : HtmlUtils.htmlEscape(value);
        }
    }
}

3.2.2 CSRF Token 校验拦截器

package com.大型加密货币交易所.risk.security.filter;
 
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
 
import java.util.UUID;
 
/**
 * CSRF 防御拦截器 —— 对状态改变请求(POST/PUT/DELETE)做 Token 校验
 * 场景:防止恶意网站诱导已登录管理员执行"修改风控规则"、"删除黑名单"等操作
 */
@Component
public class CsrfTokenInterceptor implements HandlerInterceptor {
 
    private static final String CSRF_HEADER_NAME = "X-CSRF-Token";
    private static final String CSRF_SESSION_ATTR = "CSRF_TOKEN";
 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 仅对写操作做校验,读操作放行
        String method = request.getMethod();
        if ("GET".equals(method) || "HEAD".equals(method) || "OPTIONS".equals(method)) {
            // 生成或刷新 Token(双 Cookie 模式:Token 在 Cookie 和 Header 中各一份)
            ensureCsrfToken(request);
            return true;
        }
 
        String requestToken = request.getHeader(CSRF_HEADER_NAME);
        String sessionToken = (String) request.getSession().getAttribute(CSRF_SESSION_ATTR);
 
        // SameSite=Strict Cookie 已提供基础防护,Token 校验是第二层
        if (sessionToken == null || !sessionToken.equals(requestToken)) {
            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
            response.getWriter().write("{\"error\":\"Invalid CSRF token\"}");
            return false;
        }
        return true;
    }
 
    private void ensureCsrfToken(HttpServletRequest request) {
        if (request.getSession().getAttribute(CSRF_SESSION_ATTR) == null) {
            String token = UUID.randomUUID().toString();
            request.getSession().setAttribute(CSRF_SESSION_ATTR, token);
        }
    }
}

3.2.3 SSRF 防御(URL 白名单 + 禁止内网 IP)

package com.大型加密货币交易所.risk.security.ssrf;
 
import org.springframework.stereotype.Service;
 
import java.net.*;
import java.util.*;
import java.util.regex.Pattern;
 
/**
 * SSRF 防御服务 —— 校验外部传入的 URL,防止服务端被利用访问内网资源
 * 场景:用户上传图片 URL 由服务端抓取、Webhook URL 配置、KYC 文档 OCR 回调地址
 */
@Service
public class SsrfPreventionService {
 
    // 禁止访问的私有网段
    private static final List<Pattern> BLOCKED_IP_PATTERNS = List.of(
        Pattern.compile("^127\\."),              // 127.0.0.0/8
        Pattern.compile("^10\\."),               // 10.0.0.0/8
        Pattern.compile("^172\\.(1[6-9]|2[0-9]|3[0-1])\\."), // 172.16.0.0/12
        Pattern.compile("^192\\.168\\."),        // 192.168.0.0/16
        Pattern.compile("^0\\."),                // 0.0.0.0/8
        Pattern.compile("^169\\.254\\."),        // Link-local
        Pattern.compile("^::1$"),                // IPv6 loopback
        Pattern.compile("^fc00:")                // IPv6 unique local
    );
 
    // 允许的协议(禁止 file://, ftp://, gopher:// 等)
    private static final Set<String> ALLOWED_SCHEMES = Set.of("https", "http");
 
    // 允许的域名后缀白名单(可选,根据业务需求配置)
    private static final Set<String> ALLOWED_HOST_SUFFIXES = Set.of(
        ".大型加密货币交易所.com", ".大型加密货币交易所.us", ".trustwallet.com"
    );
 
    /**
     * 校验 URL 是否安全
     */
    public void validateUrl(String urlString) {
        if (urlString == null || urlString.isBlank()) {
            throw new SecurityException("URL cannot be empty");
        }
 
        URI uri;
        try {
            uri = new URI(urlString);
        } catch (URISyntaxException e) {
            throw new SecurityException("Invalid URL format: " + urlString);
        }
 
        // 1. 协议校验
        String scheme = uri.getScheme();
        if (scheme == null || !ALLOWED_SCHEMES.contains(scheme.toLowerCase())) {
            throw new SecurityException("Scheme not allowed: " + scheme);
        }
 
        // 2. DNS 解析与 IP 校验(关键:先解析域名,再判断 IP)
        String host = uri.getHost();
        if (host == null) {
            throw new SecurityException("Invalid host in URL");
        }
 
        // 防御 DNS Rebinding:同时校验域名和解析后的 IP
        validateHostNotPrivate(host);
 
        // 3. 端口校验(禁止访问非标准端口如 22, 3306, 6379 等)
        int port = uri.getPort() == -1 ? (scheme.equalsIgnoreCase("https") ? 443 : 80) : uri.getPort();
        if (port < 1 || port > 65535 || isDangerousPort(port)) {
            throw new SecurityException("Port not allowed: " + port);
        }
 
        // 4. 可选:域名白名单校验
        validateDomainWhitelist(host);
    }
 
    private void validateHostNotPrivate(String host) {
        try {
            InetAddress[] addresses = InetAddress.getAllByName(host);
            for (InetAddress addr : addresses) {
                String ip = addr.getHostAddress();
                for (Pattern pattern : BLOCKED_IP_PATTERNS) {
                    if (pattern.matcher(ip).find()) {
                        throw new SecurityException(
                            "Access to private IP is forbidden: " + host + " -> " + ip
                        );
                    }
                }
            }
        } catch (UnknownHostException e) {
            throw new SecurityException("Cannot resolve host: " + host);
        }
    }
 
    private boolean isDangerousPort(int port) {
        return Set.of(22, 23, 25, 53, 110, 143, 3306, 5432, 6379, 27017, 9200).contains(port);
    }
 
    private void validateDomainWhitelist(String host) {
        String lowerHost = host.toLowerCase();
        boolean allowed = ALLOWED_HOST_SUFFIXES.stream().anyMatch(lowerHost::endsWith);
        if (!allowed) {
            throw new SecurityException("Domain not in whitelist: " + host);
        }
    }
}

3.3 JWT 拦截器(签名验证 + 过期检查 + 黑名单)

package com.大型加密货币交易所.risk.security.jwt;
 
import com.nimbusds.jose.*;
import com.nimbusds.jose.crypto.RSASSAVerifier;
import com.nimbusds.jwt.JWTClaimsSet;
import com.nimbusds.jwt.SignedJWT;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
 
import java.security.interfaces.RSAPublicKey;
import java.text.ParseException;
import java.time.Duration;
import java.time.Instant;
import java.util.Date;
import java.util.Set;
 
/**
 * JWT 认证拦截器 —— 生产级实现
 * 功能:签名验证 | 过期检查 | 受众校验 | scope 校验 | 黑名单(登出/吊销)| 刷新窗口
 */
@Component
public class JwtAuthenticationInterceptor implements HandlerInterceptor {
 
    private final RSAPublicKey publicKey;           // 从 KMS/HSM 加载
    private final StringRedisTemplate redisTemplate;
    private final JwtKeyProvider keyProvider;
 
    // JWT 刷新窗口:过期前 5 分钟内访问,自动颁发新 Token
    private static final long REFRESH_WINDOW_SECONDS = 300;
    private static final String BLACKLIST_KEY_PREFIX = "jwt:blacklist:";
 
    public JwtAuthenticationInterceptor(
            JwtKeyProvider keyProvider,
            StringRedisTemplate redisTemplate) {
        this.keyProvider = keyProvider;
        this.publicKey = keyProvider.getCurrentPublicKey();
        this.redisTemplate = redisTemplate;
    }
 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String authHeader = request.getHeader("Authorization");
        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
            writeError(response, HttpServletResponse.SC_UNAUTHORIZED, "Missing or invalid Authorization header");
            return false;
        }
 
        String token = authHeader.substring(7);
        try {
            SignedJWT signedJWT = SignedJWT.parse(token);
            String kid = signedJWT.getHeader().getKeyID();
 
            // 1. 算法校验 —— 防御 Alg=None 攻击
            JWSAlgorithm alg = signedJWT.getHeader().getAlgorithm();
            if (!JWSAlgorithm.RS256.equals(alg)) {
                writeError(response, HttpServletResponse.SC_FORBIDDEN, "Unsupported JWT algorithm");
                return false;
            }
 
            // 2. 签名验证(根据 kid 选择对应的公钥)
            RSAPublicKey key = keyProvider.getPublicKeyByKid(kid);
            JWSVerifier verifier = new RSASSAVerifier(key);
            if (!signedJWT.verify(verifier)) {
                writeError(response, HttpServletResponse.SC_FORBIDDEN, "Invalid JWT signature");
                return false;
            }
 
            JWTClaimsSet claims = signedJWT.getJWTClaimsSet();
 
            // 3. 过期时间校验(exp)
            Date expiration = claims.getExpirationTime();
            if (expiration == null || expiration.before(new Date())) {
                writeError(response, HttpServletResponse.SC_UNAUTHORIZED, "Token expired");
                return false;
            }
 
            // 4. 生效时间校验(nbf - not before)
            Date notBefore = claims.getNotBeforeTime();
            if (notBefore != null && notBefore.after(new Date())) {
                writeError(response, HttpServletResponse.SC_UNAUTHORIZED, "Token not yet valid");
                return false;
            }
 
            // 5. 签发者校验(iss)
            String issuer = claims.getIssuer();
            if (!"auth.大型加密货币交易所.com".equals(issuer)) {
                writeError(response, HttpServletResponse.SC_FORBIDDEN, "Invalid token issuer");
                return false;
            }
 
            // 6. 受众校验(aud)
            List<String> audience = claims.getAudience();
            if (audience == null || !audience.contains("risk-api.大型加密货币交易所.com")) {
                writeError(response, HttpServletResponse.SC_FORBIDDEN, "Invalid token audience");
                return false;
            }
 
            // 7. 黑名单校验 —— 用户登出、账户冻结、权限回收后 Token 立即失效
            String jti = claims.getJWTID();
            if (jti != null && Boolean.TRUE.equals(redisTemplate.hasKey(BLACKLIST_KEY_PREFIX + jti))) {
                writeError(response, HttpServletResponse.SC_UNAUTHORIZED, "Token revoked");
                return false;
            }
 
            // 8. Scope 校验 —— 检查当前请求所需权限
            String scope = claims.getStringClaim("scope");
            String requiredScope = inferRequiredScope(request);
            if (requiredScope != null && (scope == null || !scope.contains(requiredScope))) {
                writeError(response, HttpServletResponse.SC_FORBIDDEN, "Insufficient scope");
                return false;
            }
 
            // 9. 刷新窗口检查 —— 若 Token 即将过期,在响应头中附上新 Token
            long secondsUntilExpiry = (expiration.getTime() - System.currentTimeMillis()) / 1000;
            if (secondsUntilExpiry < REFRESH_WINDOW_SECONDS) {
                String newToken = keyProvider.refreshToken(signedJWT);
                response.setHeader("X-Refreshed-Token", newToken);
            }
 
            // 10. 将用户信息注入请求属性,供下游使用
            request.setAttribute("userId", claims.getSubject());
            request.setAttribute("mfaVerified", claims.getBooleanClaim("mfa_verified"));
            request.setAttribute("jwtClaims", claims);
 
            return true;
 
        } catch (ParseException e) {
            writeError(response, HttpServletResponse.SC_BAD_REQUEST, "Malformed JWT token");
            return false;
        } catch (JOSEException e) {
            writeError(response, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "JWT verification error");
            return false;
        }
    }
 
    private String inferRequiredScope(HttpServletRequest request) {
        String path = request.getRequestURI();
        String method = request.getMethod();
        if (path.startsWith("/api/v1/withdraw") && "POST".equals(method)) {
            return "withdraw:crypto";
        }
        if (path.startsWith("/api/v1/wallet") && "GET".equals(method)) {
            return "read:wallet";
        }
        if (path.startsWith("/api/v1/risk/rules") && "POST".equals(method)) {
            return "admin:risk";
        }
        return null;
    }
 
    private void writeError(HttpServletResponse response, int status, String message) throws IOException {
        response.setStatus(status);
        response.setContentType("application/json");
        response.getWriter().write(String.format("{\"error\":\"%s\"}", message));
    }
}

3.4 防重放攻击:Nonce + Timestamp + Redis

package com.大型加密货币交易所.risk.security.replay;
 
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
 
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.time.Instant;
import java.util.Base64;
 
/**
 * 防重放攻击校验服务 —— 面向 API Key 鉴权的交易接口
 * 场景:量化交易 API、大额提现审批、风控规则批量修改
 */
@Service
public class ReplayAttackPreventionService {
 
    private final StringRedisTemplate redisTemplate;
    private static final long TIMESTAMP_TOLERANCE_MS = 300_000; // 5 分钟窗口
    private static final Duration NONCE_TTL = Duration.ofMinutes(10);
    private static final String NONCE_KEY_PREFIX = "api:nonce:";
 
    public ReplayAttackPreventionService(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
 
    /**
     * 校验请求的三重防护
     *
     * @param apiKey      用户 API Key(标识身份)
     * @param timestamp   请求时间戳(毫秒)
     * @param nonce       唯一随机字符串(UUID)
     * @param signature   客户端生成的 HMAC-SHA256 签名
     * @param method      HTTP 方法
     * @param path        请求路径
     * @param body        请求体(JSON 字符串)
     * @param apiSecret   服务端存储的 API Secret(用于重新计算签名)
     */
    public void validateRequest(
            String apiKey,
            long timestamp,
            String nonce,
            String signature,
            String method,
            String path,
            String body,
            String apiSecret
    ) {
        // 1. 时间窗口校验 —— 防止"陈年旧请求"被重放
        long now = System.currentTimeMillis();
        if (Math.abs(now - timestamp) > TIMESTAMP_TOLERANCE_MS) {
            throw new ReplayAttackException("Request timestamp out of tolerance window");
        }
 
        // 2. Nonce 幂等校验 —— 防止"时间窗口内的完全重复请求"
        String nonceKey = NONCE_KEY_PREFIX + apiKey + ":" + nonce;
        Boolean nonceSet = redisTemplate.opsForValue().setIfAbsent(nonceKey, "1", NONCE_TTL);
        if (Boolean.FALSE.equals(nonceSet)) {
            throw new ReplayAttackException("Duplicate nonce detected — possible replay attack");
        }
 
        // 3. 签名校验 —— 防止"篡改请求体后重放"
        String expectedSignature = computeSignature(apiSecret, method, path, timestamp, nonce, body);
        if (!constantTimeEquals(expectedSignature, signature)) {
            throw new ReplayAttackException("Invalid request signature");
        }
    }
 
    /**
     * 计算 HMAC-SHA256 签名
     * 签名内容:METHOD + PATH + TIMESTAMP + NONCE + BODY
     * 格式与 大型加密货币交易所 API 标准一致
     */
    public String computeSignature(String apiSecret, String method, String path, long timestamp, String nonce, String body) {
        try {
            String payload = method.toUpperCase() + "\n" +
                    path + "\n" +
                    timestamp + "\n" +
                    nonce + "\n" +
                    (body != null ? body : "");
 
            Mac mac = Mac.getInstance("HmacSHA256");
            SecretKeySpec secretKey = new SecretKeySpec(apiSecret.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
            mac.init(secretKey);
            byte[] hash = mac.doFinal(payload.getBytes(StandardCharsets.UTF_8));
            return Base64.getEncoder().encodeToString(hash);
        } catch (Exception e) {
            throw new RuntimeException("Failed to compute HMAC signature", e);
        }
    }
 
    /**
     * 常量时间比较 —— 防御 Timing Attack(通过测量比较时间推测正确签名前缀)
     */
    private boolean constantTimeEquals(String a, String b) {
        if (a == null || b == null) return false;
        byte[] aBytes = a.getBytes(StandardCharsets.UTF_8);
        byte[] bBytes = b.getBytes(StandardCharsets.UTF_8);
        int result = 0;
        int minLen = Math.min(aBytes.length, bBytes.length);
        for (int i = 0; i < minLen; i++) {
            result |= aBytes[i] ^ bBytes[i];
        }
        return result == 0 && aBytes.length == bBytes.length;
    }
}

3.5 OAuth2 授权码模式实现(服务端)

package com.大型加密货币交易所.risk.security.oauth2;
 
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
 
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.time.Duration;
import java.time.Instant;
import java.util.Base64;
import java.util.UUID;
 
/**
 * OAuth2.0 Authorization Server 核心服务(简化版)
 * 场景:第三方量化交易平台请求访问用户 大型加密货币交易所 钱包余额
 */
@Service
public class OAuth2AuthorizationServer {
 
    private final StringRedisTemplate redisTemplate;
    private final JwtTokenIssuer tokenIssuer;
    private final ClientRegistry clientRegistry;
 
    private static final Duration AUTH_CODE_TTL = Duration.ofMinutes(10);
    private static final String AUTH_CODE_PREFIX = "oauth:code:";
 
    public OAuth2AuthorizationServer(
            StringRedisTemplate redisTemplate,
            JwtTokenIssuer tokenIssuer,
            ClientRegistry clientRegistry) {
        this.redisTemplate = redisTemplate;
        this.tokenIssuer = tokenIssuer;
        this.clientRegistry = clientRegistry;
    }
 
    /**
     * Step 1: 用户认证成功后,生成 authorization code
     *
     * @param clientId        注册的应用 ID
     * @param redirectUri     回调地址(必须与注册时一致)
     * @param codeChallenge   PKCE: S256 哈希值
     * @param scope           请求权限范围
     * @param userId          已认证用户 ID
     */
    public String generateAuthorizationCode(
            String clientId,
            String redirectUri,
            String codeChallenge,
            String scope,
            String userId
    ) {
        // 校验 client 是否存在且 redirectUri 匹配
        Client client = clientRegistry.validateClient(clientId, redirectUri);
        if (client == null) {
            throw new OAuth2Exception("Invalid client or redirect URI mismatch");
        }
 
        // 校验 scope 是否在 client 注册的权限范围内
        if (!client.getAllowedScopes().containsAll(Set.of(scope.split(" ")))) {
            throw new OAuth2Exception("Scope not allowed for this client");
        }
 
        String code = UUID.randomUUID().toString();
        String key = AUTH_CODE_PREFIX + code;
 
        // 存储 code 与 context 的映射(绑定 userId, clientId, codeChallenge)
        redisTemplate.opsForHash().putAll(key, Map.of(
            "userId", userId,
            "clientId", clientId,
            "redirectUri", redirectUri,
            "codeChallenge", codeChallenge,
            "scope", scope
        ));
        redisTemplate.expire(key, AUTH_CODE_TTL);
 
        return code;
    }
 
    /**
     * Step 2: 用 authorization code + code_verifier 换取 access token
     */
    public TokenResponse exchangeToken(
            String clientId,
            String clientSecret,
            String code,
            String codeVerifier,
            String redirectUri
    ) {
        // 校验 client credentials
        clientRegistry.authenticateClient(clientId, clientSecret);
 
        String key = AUTH_CODE_PREFIX + code;
        Map<Object, Object> codeContext = redisTemplate.opsForHash().entries(key);
 
        if (codeContext.isEmpty()) {
            throw new OAuth2Exception("Invalid or expired authorization code");
        }
 
        // 防御:redirectUri 必须与申请 code 时一致
        if (!redirectUri.equals(codeContext.get("redirectUri"))) {
            throw new OAuth2Exception("Redirect URI mismatch");
        }
 
        // PKCE 校验:验证 code_verifier 的 S256 哈希是否等于 code_challenge
        String storedChallenge = (String) codeContext.get("codeChallenge");
        if (!verifyCodeChallenge(codeVerifier, storedChallenge)) {
            throw new OAuth2Exception("PKCE verification failed");
        }
 
        // 一次性使用:立即删除 code,防止重放换取 Token
        redisTemplate.delete(key);
 
        String userId = (String) codeContext.get("userId");
        String scope = (String) codeContext.get("scope");
 
        // 颁发 Token
        String accessToken = tokenIssuer.issueAccessToken(userId, clientId, scope, Duration.ofMinutes(15));
        String refreshToken = tokenIssuer.issueRefreshToken(userId, clientId, Duration.ofDays(30));
 
        return new TokenResponse(accessToken, refreshToken, "Bearer", 900, scope);
    }
 
    private boolean verifyCodeChallenge(String verifier, String challenge) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            byte[] hash = digest.digest(verifier.getBytes(StandardCharsets.UTF_8));
            String computed = Base64.getUrlEncoder().withoutPadding().encodeToString(hash);
            return computed.equals(challenge);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }
}

3.6 API Key 认证与权限校验

package com.大型加密货币交易所.risk.security.apikey;
 
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
 
import java.time.Duration;
import java.util.Set;
 
/**
 * API Key 管理服务 —— 面向量化交易和机构客户
 * 功能:Key 生成 | 权限绑定 | IP 白名单 | 速率限制 | 审计日志
 */
@Service
public class ApiKeyService {
 
    private final StringRedisTemplate redisTemplate;
    private final ApiKeyRepository apiKeyRepository;
    private final AuditLogService auditLogService;
 
    private static final String API_KEY_CACHE_PREFIX = "apikey:meta:";
    private static final Duration CACHE_TTL = Duration.ofMinutes(5);
 
    public ApiKeyService(
            StringRedisTemplate redisTemplate,
            ApiKeyRepository apiKeyRepository,
            AuditLogService auditLogService) {
        this.redisTemplate = redisTemplate;
        this.apiKeyRepository = apiKeyRepository;
        this.auditLogService = auditLogService;
    }
 
    /**
     * 校验 API Key 并返回其元数据
     */
    public ApiKeyMetadata authenticate(String apiKey, String clientIp) {
        // 1. 从 Redis 缓存读取
        String cacheKey = API_KEY_CACHE_PREFIX + apiKey;
        ApiKeyMetadata metadata = readFromCache(cacheKey);
 
        if (metadata == null) {
            // 2. 缓存未命中,查数据库(注意:此处 SQL 使用预编译)
            metadata = apiKeyRepository.findByApiKey(apiKey)
                    .orElseThrow(() -> new AuthenticationException("Invalid API Key"));
            writeToCache(cacheKey, metadata);
        }
 
        // 3. 状态校验
        if (!metadata.isActive()) {
            auditLogService.recordFailedAuth(apiKey, clientIp, "Key inactive or revoked");
            throw new AuthenticationException("API Key is inactive");
        }
 
        if (metadata.getExpiresAt() != null && metadata.getExpiresAt().isBefore(Instant.now())) {
            throw new AuthenticationException("API Key expired");
        }
 
        // 4. IP 白名单校验(若有配置)
        if (!metadata.getAllowedIps().isEmpty() && !metadata.getAllowedIps().contains(clientIp)) {
            auditLogService.recordFailedAuth(apiKey, clientIp, "IP not in whitelist");
            throw new AuthenticationException("Client IP not authorized: " + clientIp);
        }
 
        // 5. 权限层级校验
        if (metadata.getPermissions().isEmpty()) {
            throw new AuthenticationException("API Key has no permissions");
        }
 
        return metadata;
    }
 
    /**
     * 创建新的 API Key(用于机构客户或内部服务间调用)
     */
    public ApiKeyPair createApiKey(
            Long userId,
            String label,
            Set<ApiPermission> permissions,
            Set<String> allowedIps,
            Duration ttl
    ) {
        String apiKey = "ak_" + generateSecureRandomString(32);
        String apiSecret = "sk_" + generateSecureRandomString(64);
 
        // 仅存储 API Secret 的哈希值(BCrypt),原始值仅返回一次
        String secretHash = BCrypt.hashpw(apiSecret, BCrypt.gensalt(12));
 
        ApiKeyMetadata metadata = new ApiKeyMetadata();
        metadata.setApiKey(apiKey);
        metadata.setSecretHash(secretHash);
        metadata.setUserId(userId);
        metadata.setLabel(label);
        metadata.setPermissions(permissions);
        metadata.setAllowedIps(allowedIps);
        metadata.setCreatedAt(Instant.now());
        metadata.setExpiresAt(ttl != null ? Instant.now().plus(ttl) : null);
        metadata.setActive(true);
 
        apiKeyRepository.save(metadata);
 
        auditLogService.recordKeyCreation(userId, apiKey, label);
 
        return new ApiKeyPair(apiKey, apiSecret); // Secret 仅返回这一次
    }
 
    /**
     * 吊销 API Key(用户登出、账户异常、权限变更时)
     */
    public void revokeApiKey(String apiKey, String reason, Long operatorId) {
        apiKeyRepository.deactivate(apiKey);
        redisTemplate.delete(API_KEY_CACHE_PREFIX + apiKey);
 
        auditLogService.recordKeyRevocation(apiKey, reason, operatorId);
    }
 
    private String generateSecureRandomString(int length) {
        byte[] bytes = new byte[length];
        new java.security.SecureRandom().nextBytes(bytes);
        return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes).substring(0, length);
    }
}

3.7 敏感数据脱敏(身份证号、手机号、银行卡、钱包地址)

package com.大型加密货币交易所.risk.security.masking;
 
import org.springframework.stereotype.Component;
 
import java.util.regex.Pattern;
 
/**
 * 敏感数据脱敏服务 —— KYC 数据、支付信息、个人身份信息
 * 原则:展示时脱敏、日志中脱敏、数据库中加密、传输中 TLS
 */
@Component
public class DataMaskingService {
 
    /**
     * 身份证号脱敏:保留前 3 位和后 4 位
     * 示例:110101199001011234 -> 110***********1234
     */
    public String maskIdCard(String idCard) {
        if (idCard == null || idCard.length() < 10) return "****";
        return idCard.substring(0, 3) + "*".repeat(idCard.length() - 7) + idCard.substring(idCard.length() - 4);
    }
 
    /**
     * 手机号脱敏:保留前 3 位和后 4 位
     * 示例:13812345678 -> 138****5678
     */
    public String maskPhone(String phone) {
        if (phone == null || phone.length() != 11) return "****";
        return phone.substring(0, 3) + "****" + phone.substring(7);
    }
 
    /**
     * 银行卡号脱敏:保留后 4 位
     * 示例:6222021234567890123 -> ****************0123
     */
    public String maskBankCard(String bankCard) {
        if (bankCard == null || bankCard.length() < 8) return "****";
        int visibleLen = 4;
        int maskLen = bankCard.length() - visibleLen;
        return "*".repeat(maskLen) + bankCard.substring(maskLen);
    }
 
    /**
     * 加密货币钱包地址脱敏:保留前 6 位和后 4 位
     * 示例:0x71C7656EC7ab88b098defB751B7401B5f6d8976F -> 0x71C7************976F
     */
    public String maskWalletAddress(String address) {
        if (address == null || address.length() < 12) return "****";
        return address.substring(0, 6) + "..." + address.substring(address.length() - 4);
    }
 
    /**
     * 邮箱脱敏:保留前 2 位和 @ 后的域名
     * 示例:[email protected] -> sa****@gmx.com
     */
    public String maskEmail(String email) {
        if (email == null || !email.contains("@")) return "****";
        String[] parts = email.split("@");
        String local = parts[0];
        String domain = parts[1];
        if (local.length() <= 2) return "**@" + domain;
        return local.substring(0, 2) + "****@" + domain;
    }
 
    /**
     * 通用字符串脱敏:保留前 prefixLen 和后 suffixLen
     */
    public String maskGeneric(String value, int prefixLen, int suffixLen) {
        if (value == null || value.length() <= prefixLen + suffixLen) return "****";
        return value.substring(0, prefixLen) + "****" + value.substring(value.length() - suffixLen);
    }
 
    /**
     * 日志脱敏:对 JSON/文本中的敏感字段做正则替换
     * 场景:避免身份证号、手机号意外打印到日志中
     */
    public String sanitizeForLog(String content) {
        if (content == null) return null;
 
        // 手机号
        content = content.replaceAll(
            "(1[3-9]\\d)\\d{4}(\\d{4})",
            "$1****$2"
        );
 
        // 身份证号
        content = content.replaceAll(
            "(\\d{3})\\d{11}(\\d{4})",
            "$1***********$2"
        );
 
        // 银行卡号(16-19 位数字)
        content = content.replaceAll(
            "\\d{12}(\\d{4})",
            "************$1"
        );
 
        return content;
    }
}
 
/**
 * 配合 Jackson 的脱敏注解 + 序列化器
 */
package com.大型加密货币交易所.risk.security.masking;
 
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 
import java.io.IOException;
import java.lang.annotation.*;
 
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@JsonSerialize(using = MaskedFieldSerializer.class)
public @interface MaskedField {
    MaskType value();
}
 
enum MaskType {
    PHONE, ID_CARD, BANK_CARD, WALLET_ADDRESS, EMAIL
}
 
class MaskedFieldSerializer extends JsonSerializer<String> {
 
    private final DataMaskingService maskingService = new DataMaskingService();
 
    @Override
    public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        // 通过反射获取字段上的注解类型(简化实现)
        // 实际生产中使用 ContextualSerializer 获取注解配置
        if (value == null) {
            gen.writeNull();
            return;
        }
        // 默认做通用脱敏,完整实现需配合 ContextualSerializer
        gen.writeString(maskingService.maskGeneric(value, 3, 4));
    }
}

3.8 Spring Security 生产级配置

package com.大型加密货币交易所.risk.config;
 
import com.大型加密货币交易所.risk.security.apikey.ApiKeyAuthenticationFilter;
import com.大型加密货币交易所.risk.security.jwt.JwtAuthenticationInterceptor;
import com.大型加密货币交易所.risk.security.filter.CsrfTokenInterceptor;
import com.大型加密货币交易所.risk.security.filter.XssFilter;
import com.大型加密货币交易所.risk.security.replay.ReplayAttackPreventionService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.security.web.csrf.CookieCsrfTokenRepository;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
/**
 * Spring Security 安全配置 —— Risk 风控后台管理 + 开放 API 双链策略
 */
@Configuration
@EnableWebSecurity
@EnableMethodSecurity(prePostEnabled = true)
public class SecurityConfig implements WebMvcConfigurer {
 
    private final JwtAuthenticationInterceptor jwtInterceptor;
    private final ApiKeyAuthenticationFilter apiKeyFilter;
    private final CsrfTokenInterceptor csrfInterceptor;
    private final XssFilter xssFilter;
 
    public SecurityConfig(
            JwtAuthenticationInterceptor jwtInterceptor,
            ApiKeyAuthenticationFilter apiKeyFilter,
            CsrfTokenInterceptor csrfInterceptor,
            XssFilter xssFilter) {
        this.jwtInterceptor = jwtInterceptor;
        this.apiKeyFilter = apiKeyFilter;
        this.csrfInterceptor = csrfInterceptor;
        this.xssFilter = xssFilter;
    }
 
    /**
     * Filter Chain 1: 开放 API(量化交易接口)—— 无 Session,API Key + 签名 + 防重放
     */
    @Bean
    @Order(1)
    public SecurityFilterChain apiFilterChain(HttpSecurity http) throws Exception {
        http
            .securityMatcher("/api/v1/trading/**", "/api/v1/withdraw/**", "/api/v1/wallet/**")
            .csrf(AbstractHttpConfigurer::disable) // API 接口无 Cookie Session,关闭 CSRF
            .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .addFilterBefore(apiKeyFilter, UsernamePasswordAuthenticationFilter.class)
            .authorizeHttpRequests(auth -> auth
                .requestMatchers(HttpMethod.POST, "/api/v1/withdraw").hasAuthority("WITHDRAW_CRYPTO")
                .requestMatchers(HttpMethod.GET, "/api/v1/wallet/balance").hasAnyAuthority("READ_WALLET", "TRADE_SPOT")
                .requestMatchers("/api/v1/trading/**").hasAuthority("TRADE_SPOT")
                .anyRequest().authenticated()
            );
        return http.build();
    }
 
    /**
     * Filter Chain 2: 风控管理后台 —— JWT + CSRF + Session
     */
    @Bean
    @Order(2)
    public SecurityFilterChain adminFilterChain(HttpSecurity http) throws Exception {
        http
            .securityMatcher("/admin/**", "/api/v1/risk/**")
            .csrf(csrf -> csrf
                .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse())
                .ignoringRequestMatchers("/api/v1/risk/webhooks/**") // Webhook 端点跳过 CSRF
            )
            .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED))
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/admin/login", "/admin/health").permitAll()
                .requestMatchers("/admin/risk/rules/**").hasRole("RISK_ADMIN")
                .requestMatchers("/admin/users/**").hasAnyRole("RISK_ADMIN", "COMPLIANCE_OFFICER")
                .requestMatchers("/api/v1/risk/audit-logs").hasRole("AUDITOR")
                .anyRequest().authenticated()
            )
            .addFilterAfter(xssFilter, UsernamePasswordAuthenticationFilter.class)
            .exceptionHandling(ex -> ex
                .accessDeniedHandler((req, res, exd) -> {
                    res.setStatus(403);
                    res.setContentType("application/json");
                    res.getWriter().write("{\"error\":\"Access denied\",\"code\":\"FORBIDDEN\"}");
                })
                .authenticationEntryPoint((req, res, exa) -> {
                    res.setStatus(401);
                    res.setContentType("application/json");
                    res.getWriter().write("{\"error\":\"Authentication required\",\"code\":\"UNAUTHORIZED\"}");
                })
            );
        return http.build();
    }
 
    /**
     * Filter Chain 3: 公共端点(健康检查、OAuth2 授权端点)
     */
    @Bean
    @Order(3)
    public SecurityFilterChain publicFilterChain(HttpSecurity http) throws Exception {
        http
            .securityMatcher("/health", "/ready", "/oauth/authorize", "/oauth/token", "/public/**")
            .csrf(AbstractHttpConfigurer::disable)
            .authorizeHttpRequests(auth -> auth.anyRequest().permitAll());
        return http.build();
    }
 
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(12); // 强度 12,耗时约 250-300ms
    }
 
    /**
     * MVC 拦截器注册:JWT 和 CSRF 通过 Interceptor 而非 Filter 实现更细粒度控制
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(jwtInterceptor)
                .addPathPatterns("/api/v1/risk/**", "/admin/**")
                .excludePathPatterns("/admin/login", "/admin/health");
 
        registry.addInterceptor(csrfInterceptor)
                .addPathPatterns("/admin/**", "/api/v1/risk/rules/**");
    }
}

4. 业界案例

4.1 阿里巴巴:全链路 API 安全防护与 WAF 实践

背景:双 11 期间,阿里巴巴面临着全球规模最大的 API 攻击面。其开放平台每天处理数十亿次 API 调用,任何一个鉴权漏洞都可能导致商家数据泄露或交易篡改。

防御体系:

  1. API 网关层统一鉴权:所有流量经过阿里云 API Gateway,统一执行签名验证(HMAC-SHA256)、Timestamp 窗口校验、Nonce 幂等、IP 白名单。与本文 3.4 节的防重放攻击设计完全对齐。

  2. 多因子 Token 体系:

    • Access Token(15 分钟,JWT)+ Refresh Token(7 天, opaque token 存储于 Redis)
    • 关键操作(如修改收款账户、大额转账)需额外校验"操作 Token"(SMS/Email 验证码生成的一次性 Token)
  3. 风控联动:当 API 网关检测到异常(如短时间内大量 403 响应、签名失败率突增),实时将客户端 IP 和设备指纹投递到风控大脑,触发滑块验证码或临时封禁。

踩坑教训:

  • Kid 轮换导致的缓存雪崩:一次 JWT 公钥轮换时,由于 CDN 缓存了旧 JWKS(JSON Web Key Set)长达 24 小时,导致部分 Region 的 Token 验证大面积失败。后改为 JWKS 响应头中加入 Cache-Control: max-age=300,并保留新旧 Key 重叠期 7 天。
  • 日志中的 API Secret 泄露:早期部分服务在异常堆栈中打印了完整请求 URL(包含 query param),而部分旧版 SDK 将 Secret 放在 query param 中。后引入统一的日志脱敏组件(类同本文 3.7 节的 sanitizeForLog),在 Logback 的 PatternLayout 中做正则清洗。

4.2 Coinbase / 大型加密货币交易所:加密货币交易所的 API Key 安全事件与防护演进

背景:加密货币交易所是黑客攻击的重灾区。2018-2022 年间,多家交易所因 API Key 泄露导致用户资产被盗,其中最著名的案例是某交易所 API Key 批量泄露事件(2022 年),攻击者通过钓鱼邮件获取了大量用户的只读 API Key,结合第三方交易机器人的漏洞,发起恶意交易。

大型加密货币交易所 的防御演进:

  1. 权限最小化(Least Privilege):API Key 权限细分为 READ_INFO、SPOT_TRADE、MARGIN_TRADE、WITHDRAWAL 等。特别是 WITHDRAWAL 权限默认关闭,开启需通过邮箱 + 2FA + 人脸识别三重校验。

  2. IP 白名单强制化:凡开启提现权限的 API Key,必须绑定 IP 白名单(最多 20 个),且不支持通配符。这与本文 3.6 节 ApiKeyService 中的 allowedIps 校验逻辑一致。

  3. Withdrawal Address Whitelist:除了 API Key 的 IP 白名单,提现目标地址也必须预先在 Web 端加入白名单。API 端发起的提现请求只能指向白名单地址,即使 API Key 泄露,资产也无法被转往陌生地址。

  4. 实时审计与熔断:大型加密货币交易所 的风控系统会对 API 交易行为做实时模式识别。例如:

    • 一个长期只读API突然开始下单 -> 触发 MFA 重新验证
    • 下单频率超过历史基线 10 倍 -> 临时限速 + 告警
    • 同一 API Key 在 1 秒内从 3 个不同国家 IP 调用 -> 立即冻结 Key 并通知用户

Coinbase 的"Keyless"架构创新:

Coinbase 在 2023 年推出了 MPC(Multi-Party Computation)API 签名:API Key 不再是一个单一的 Secret,而是被分片存储在 Coinbase 服务器和用户本地设备上。任何 API 请求需要双方共同签名,单方泄露无法伪造请求。虽然实现复杂,但代表了 API Key 管理的未来方向。

4.3 腾讯:游戏风控中的 CSRF 与 XSS 联合防御

背景:腾讯游戏充值平台曾遭受大规模 XSS + CSRF 组合攻击。攻击者在游戏论坛发布包含恶意脚本的帖子(XSS),当已登录的充值管理员浏览帖子时,脚本自动发起 CSRF 请求,将游戏币充值到攻击者账户。

联合防御策略:

  • Content Security Policy(CSP):管理员后台页面启用严格 CSP,禁止内联脚本执行,XSS 注入的脚本无法运行。
  • SameSite=Lax + Strict 分层:普通操作用 SameSite=Lax,资金操作用 SameSite=Strict + 额外 CSRF Token。
  • 操作二次确认:所有涉及资产变动的操作,在服务端生成一个临时确认 Token,通过独立通道(企业微信/短信)发送给操作员,管理员需在页面上输入该 Token 才能完成操作。

5. 业务场景对照与注意事项

5.1 Crypto Exchange Risk 系统的安全映射

┌─────────────────────────────────────────────────────────────────────────┐
│                 加密货币交易所安全防御全景图                               │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│   [用户层]               [接入层]                [服务层]                 │
│                                                                         │
│   ┌─────────┐         ┌──────────┐         ┌─────────────────────┐     │
│   │ KYC 上传 │  ──→   │ WAF/CDN  │  ──→   │ API Gateway         │     │
│   │ 护照/驾照│         │ DDoS 防护│         │ • JWT/API Key 校验   │     │
│   └─────────┘         └──────────┘         │ • 防重放攻击          │     │
│        ↓                                   │ • 速率限制            │     │
│   ┌─────────────┐                          └─────────────────────┘     │
│   │ 文件类型校验 │                                    ↓                  │
│   │ 图片 EXIF   │                         ┌─────────────────────┐     │
│   │ 脱敏存储    │                         │ Risk Rule Engine    │     │
│   └─────────────┘                         │ • 规则热更新鉴权     │     │
│                                           │ • 管理员 RBAC       │     │
│   [交易层]                                 └─────────────────────┘     │
│                                                                         │
│   ┌─────────────┐    ┌──────────────┐    ┌─────────────────────┐     │
│   │ 下单 API    │───→│ 风控决策节点  │───→│ Wallet Service      │     │
│   │ • API Key   │    │ • 实时规则    │    │ • 提现 2FA          │     │
│   │ • 签名校验  │    │ • ML 模型    │    │ • 多签钱包          │     │
│   │ • 频率限制  │    │ • 设备指纹    │    │ • 地址白名单        │     │
│   └─────────────┘    └──────────────┘    └─────────────────────┘     │
│                                                                         │
│   [数据层]                                                               │
│   ┌─────────────┐    ┌──────────────┐    ┌─────────────────────┐     │
│   │ MongoDB     │    │ Redis        │    │ Kafka               │     │
│   │ • KYC 数据  │    │ • Token 黑名单│    │ • 审计日志          │     │
│   │   AES-256-GCM│   │ • Nonce 存储  │    │ • 敏感信息脱敏      │     │
│   │ • 字段级加密│    │ • 频控计数器  │    │   后写入            │     │
│   └─────────────┘    └──────────────┘    └─────────────────────┘     │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

5.2 安全基础在 Crypto Risk 中的具体映射

安全基础Crypto Exchange 场景大型加密货币交易所-Like 实践
SQL 注入防御风控订单查询、用户标签检索、交易流水审计所有用户输入参数使用 #{},动态表名使用白名单校验
XSS 防御KYC 备注字段、客服工单内容、用户昵称展示输出端 HTML 编码 + CSP 策略 + 富文本使用 DOMPurify
CSRF 防御管理员修改风控规则、冻结/解冻账户、调整 API 权限SameSite=Strict Cookie + CSRF Token + 操作二次确认
SSRF 防御Webhook 配置、KYC 文档 OCR 回调、第三方价格源拉取URL 协议白名单(仅 https)+ IP 黑名单(禁止内网)+ 域名白名单
JWT 安全用户 Web 端会话、管理后台登录、OpenAPI 授权RS256 + exp/nbf/iss/aud 全校验 + JTI 黑名单 + 15 分钟短有效期
防重放攻击提现审批、API 下单、批量黑名单导入Timestamp 5 分钟窗口 + UUID nonce Redis 去重 + HMAC-SHA256 签名
API Key 管理量化交易机器人、机构客户接入、内部服务间调用权限分级(读/交易/提现)+ IP 白名单 + 地址白名单 + 审计日志
敏感数据脱敏KYC 护照号、银行卡、手机号、钱包地址的展示与日志展示层:maskIdCard/maskBankCard;日志层:正则全局脱敏

5.3 常见误区 vs 正确做法

误区正确做法原因
"用了 HTTPS 就安全了"HTTPS 是传输层安全,仍需防御应用层注入、XSS、CSRFTLS 防窃听,不防服务端漏洞
"JWT 可以替代 Session"JWT 适合无状态认证,但吊销/黑名单需要 Redis 状态存储纯 JWT 无法做到"服务端立即登出"
"前端做了校验就够了"所有输入校验必须在服务端重做前端校验是 UX 优化,服务端校验才是安全边界
"API Secret 放在前端环境变量"服务端代理或 Backend-for-Frontend(BFF)模式前端任何代码/环境变量都可被用户提取
"Nonce 用随机数即可"Nonce 需配合 Timestamp 和 Redis 去重单独的随机数无法防御重放,需服务端状态记录
"脱敏只在 UI 层做"日志、API 响应、数据库备份全链路脱敏/加密攻击者常直接读取数据库或日志文件
"Spring Security 默认配置够用"必须自定义 FilterChain,关闭默认表单登录默认配置包含大量不需要的 Filter,扩大攻击面

5.4 选型建议

场景推荐方案不推荐
用户 Web 会话JWT (RS256) + Refresh Token + HttpOnly Cookie长有效期 JWT、LocalStorage 存储
量化交易 APIAPI Key + HMAC-SHA256 + Nonce + TimestampOAuth2 授权码模式(太繁琐)
第三方应用接入OAuth2.0 + PKCE + Scope 分级直接颁发用户密码
内部服务间调用mTLS(双向 TLS)+ Short-lived JWT共享 API Key
管理员后台Session + CSRF Token + MFA + IP 白名单纯 JWT + 无 CSRF 防护

6. FAQ 与高频追问

Q1: JWT 的 Token 被盗后,服务端如何立即吊销?纯 JWT 不是无状态的吗?

答:"服务端无状态"是一个常见误解。虽然 JWT 本身包含自包含的声明,但生产环境中必须引入轻量级状态来实现吊销:

  1. 黑名单(Denylist):JWT 的 jti(JWT ID)作为唯一标识,登出/冻结时写入 Redis:SET jwt:blacklist:<jti> 1 EX <剩余过期时间>。每次验签时先查 Redis。
  2. 短有效期 + 刷新机制:Access Token 15 分钟, Refresh Token 轮换(每次使用 Refresh Token 后颁发新的 Refresh Token,旧的作废)。即使 Access Token 被盗,窗口期只有 15 分钟。
  3. 关键操作二次认证:对于提现、修改密码等高危操作,即使 JWT 有效,仍需校验"操作 Token"(短信/邮箱/G Authenticator)。

追问:黑名单查 Redis 不是有性能损耗吗?

答:Redis 单次 GET 约 0.5ms,且可以使用 Lua 脚本将"黑名单检查 + 解码 + 验签"合并为一次 Redis 执行。若追求极致性能,可采用两级缓存:本地 Caffeine 缓存热点黑名单(1 分钟 TTL)+ Redis 全局存储。或者改用白名单机制:仅对活跃用户签发短期 JWT,用户登出时直接删除白名单记录。

Q2: 如何防御 JWT 的 Algorithm Confusion(算法混淆)攻击?

答:Algorithm Confusion 攻击的核心是攻击者将 alg 从 RS256 改为 HS256,然后用服务端的公钥(公开的)作为 HMAC 的 Secret 来签名 Token,服务端误用公钥验证 HMAC 导致通过。

防御措施:

  1. 白名单校验 alg:服务端硬编码允许的算法列表(如仅 RS256),拒绝 none/HS256/HS384 等。
  2. 密钥隔离:RSA 的公钥和 HMAC 的 Secret 物理隔离,即使攻击者获取公钥也无法用于 HMAC。
  3. 使用成熟库:如 Nimbus JOSE + JWT,其 JWSVerifier 会根据算法类型自动选择验证器,不会混用 RSA 公钥验证 HMAC。

Q3: OAuth2.0 的 Authorization Code 泄露了怎么办?PKCE 能完全防御吗?

答:

  • 没有 PKCE:攻击者截获 code 后,可直接向 Token Endpoint 换取 Access Token(因为 client_secret 对于公共客户端通常存储在前端,可被逆向)。
  • 有 PKCE:攻击者截获 code 但没有 code_verifier,无法换取 Token。因为 code_challenge = SHA256(code_verifier),是单向哈希。
  • 但 PKCE 不能防御所有攻击:如果攻击者在授权流程开始前就劫持了客户端(如恶意浏览器插件替换了 code_challenge),则 PKCE 失效。此场景需结合 DPoP(Demonstrating Proof-of-Possession) 或 mTLS。

Q4: 防重放攻击中,如果客户端和服务端时钟不同步怎么办?

答:

  1. 允许容忍窗口:如本文 3.4 节所示,TIMESTAMP_TOLERANCE_MS = 300000(5 分钟),覆盖绝大多数时钟漂移。
  2. 服务端返回时钟偏移:首次 API 调用返回 X-Server-Time 响应头,客户端计算偏移量并在后续请求中自动校准。
  3. NTP 强制同步:在 API 文档中明确要求客户端必须启用 NTP 同步,并在 SDK 中内置 NTP 校准逻辑。
  4. 分级策略:对于读取类 API,允许更大的时间窗口(10 分钟);对于提现/转账等写操作,严格限制为 1 分钟,并要求客户端在请求前先做时间同步探测。

Q5: 为什么 SSRF 防御中不能仅做域名白名单,还必须解析 IP?

答:

DNS Rebinding(DNS 重绑定)攻击可以绕过纯域名白名单:

  1. 攻击者注册一个域名 evil.com,初始 DNS 指向 1.2.3.4(公网 IP,在白名单外但可通过校验)。
  2. 服务端在校验域名时解析为 1.2.3.4,认为是公网地址,通过校验。
  3. 攻击者迅速修改 DNS 记录,将 evil.com 指向 10.0.0.1(内网地址)。
  4. 服务端实际发起 HTTP 请求时再次解析 DNS,此时得到 10.0.0.1,成功访问内网。

防御:必须执行双重校验:

  • 第一次:校验域名是否在白名单
  • 第二次:解析域名得到实际 IP,校验 IP 是否属于私有网段
  • 更严格的方案:使用固定 DNS 缓存(如 Java 的 InetAddress 缓存 + 自定义 DNS Resolver),确保校验和实际请求使用同一解析结果。

Q6: 在加密货币交易所中,API Key 的 Secret 如何安全存储?

答:

  • 服务端:仅存储 bcrypt/scrypt 哈希值,原始 Secret 在生成后仅展示一次。数据库泄露也无法还原 Secret。
  • 客户端:量化机构应将 Secret 存储在硬件安全模块(HSM)、密钥管理服务(AWS KMS / Azure Key Vault / HashiCorp Vault)或本地加密文件中(使用系统钥匙串)。
  • 传输:永远不在 URL query param 中传递 Secret,仅放在 Header 中,且全程 HTTPS。
  • 轮换:支持 API Key 无感轮换(新旧 Key 同时有效 24 小时),机构可在低峰期切换。
  • 审计:每次 API Key 的使用(成功/失败)都记录到不可篡改的审计日志(如写入区块链或 WORM 存储)。

Q7: 敏感数据在数据库中是加密存储还是哈希存储?

答:取决于数据的使用方式:

数据类型存储方式原因示例
密码哈希(bcrypt/Argon2)服务端永远不需要知道明文密码用户登录密码
API Secret哈希(bcrypt)仅用于校验,生成后不再展示交易 API Secret
身份证号加密(AES-256-GCM + KMS)需要解密用于 KYC 合规比对护照号
银行卡号加密 + Tokenization需要解密用于支付,但日常用 Token 替代用户绑定银行卡
手机号加密或掩码存储需要用于短信通知,但展示时脱敏138****5678
日志内容实时脱敏后存储合规要求,防止内部泄露所有含 PII 的日志

Q8: 如果已经发生了 JWT Secret(RS256 Private Key)泄露,如何紧急止损?

答:

  1. 立即轮换密钥:使用备用密钥对(已预生成并安全存储),更新 kid 指向新公钥。
  2. 全网推送 JWKS:确保所有服务节点在秒级获取到新公钥(使用配置中心如 Nacos/Consul 推送)。
  3. 旧 Token 批量吊销:遍历 Redis 中所有活跃用户会话,将旧 Key 签发的 Token jti 批量加入黑名单。
  4. 强制重新登录:对所有用户下发"会话失效"通知,要求重新输入密码 + 2FA。
  5. 根因排查:检查 HSM/KMS 访问日志、代码仓库提交记录、CI/CD 流水线日志,定位泄露源。
  6. 事后加固:缩短 Key 有效期(从 90 天改为 30 天),启用自动轮换(AWS KMS Automatic Rotation)。

最后提示(Interview Tip):

在 大型加密货币交易所 Risk 面试中,安全问题的回答务必体现出**"纵深防御(Defense in Depth)"**的思维——不要只谈某一个点的防御,而是要从输入层、传输层、会话层、应用层、数据层逐层展开。例如被问到"如何防止 SQL 注入"时,不仅要答 PreparedStatement,还要补充 WAF 规则、最小权限数据库账号、数据库审计日志、以及一旦注入后的响应预案(如蜜表、SQL 防火墙)。这种体系化的回答才能体现 Senior/Staff 级别的安全架构能力。