
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) | 将恶意代码注入到查询/命令中执行 | 像给快递单上的"备注栏"写上"请转交给我邻居(其实是小偷)",分拣系统照做了 |
| XSS | Cross-Site Scripting | 将恶意脚本注入到网页中,在用户浏览器执行 | 像在图书馆的畅销书里夹了一张纸条,每个借书的人回家打开书都会看到并执行纸条上的指令 |
| CSRF | Cross-Site Request Forgery | 诱导已登录用户在不知情的情况下执行非预期操作 | 像偷偷把一封已经签好名的空白支票塞到别人的邮箱里,邮差(浏览器)自动帮你投递到银行 |
| SSRF | Server-Side Request Forgery | 让服务器发起攻击者控制的请求,访问内网/元数据 | 像打电话到前台说"我是老板,把内部文件发到这个邮箱",前台因为信任内部来电照做了 |
| Broken Authentication | 身份认证缺陷 | 会话管理/凭证验证漏洞导致身份被冒用 | 像用一张复印的员工卡刷开了公司所有的门禁 |
| Sensitive Data Exposure | 敏感数据泄露 | 未加密/脱敏存储或传输敏感信息 | 像把保险箱密码写在便利贴上贴在保险箱门上 |
| Broken Access Control | 访问控制失效 | 未做权限校验或校验不当 | 像酒店电梯没有房卡验证,任何人都能去总统套房楼层 |
类比:安全防御体系 = 中世纪城堡
- 输入校验 = 护城河 + 吊桥(第一道防线,阻止敌人靠近城墙)
- HTTPS/TLS = 信使的密语(即使信使被截获,敌人也看不懂内容)
- JWT/OAuth2 = 贵族纹章(证明你是谁、来自哪个家族、有什么权限)
- WAF/RBAC = 城墙上的守卫 + 城内分区(不同区域有不同准入级别)
- 加密/脱敏 = 藏宝图的分割保存(即使攻破城堡,也找不到完整宝藏)
1.2 为什么安全在 Risk 系统中是生死线
在传统电商中,安全漏洞可能导致用户信息泄露或资金损失;在加密货币交易所中:
- 资产不可逆:区块链交易不可回滚,一次成功攻击 = 永久损失
- 高价值目标:交易所钱包常持有数十亿美金的资产,是 APT 攻击(Advanced Persistent Threat)的首要目标
- 合规高压:MiCA、FCA、MAS 等监管要求严格的 KYC/AML 数据保护,违规罚款可达全球营收的 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 的本质区别
| 维度 | XSS | CSRF |
|---|---|---|
| 攻击目标 | 用户浏览器(客户端) | 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 │
│ ) │
└────────────────────────────────────────────────────────────────┘
关键安全原则:
- 密钥隔离:签名密钥(尤其是 RS256 的 private key)必须存储在 HSM/KMS 中,严禁硬编码
- 算法混淆防御(Alg=None Attack):服务端必须校验
alg字段为预期算法,拒绝none/null - 密钥 ID 轮换:通过
kid支持密钥平滑轮换,旧密钥签发的 Token 逐步失效 - 短有效期:Access Token 建议 15 分钟,配合 Refresh Token 机制
2.4 防重放攻击(Replay Attack)的三重校验
三重校验 = 时间窗口 + 幂等 nonce + 签名验证,缺一不可:
- 没有时间窗口:攻击者可以无限期保存请求,在未来任意时间重放
- 没有 nonce:在时间窗口内,完全相同的请求可以被重放多次
- 没有签名:攻击者可以篡改请求体后重放
2.5 OAuth2.0 授权码流程(Authorization Code Flow with PKCE)
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 位和 @ 后的域名
* 示例:satoshin@gmx.com -> 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 调用,任何一个鉴权漏洞都可能导致商家数据泄露或交易篡改。
防御体系:
-
API 网关层统一鉴权:所有流量经过阿里云 API Gateway,统一执行签名验证(HMAC-SHA256)、Timestamp 窗口校验、Nonce 幂等、IP 白名单。与本文 3.4 节的防重放攻击设计完全对齐。
-
多因子 Token 体系:
- Access Token(15 分钟,JWT)+ Refresh Token(7 天, opaque token 存储于 Redis)
- 关键操作(如修改收款账户、大额转账)需额外校验"操作 Token"(SMS/Email 验证码生成的一次性 Token)
-
风控联动:当 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,结合第三方交易机器人的漏洞,发起恶意交易。
大型加密货币交易所 的防御演进:
-
权限最小化(Least Privilege):API Key 权限细分为
READ_INFO、SPOT_TRADE、MARGIN_TRADE、WITHDRAWAL等。特别是WITHDRAWAL权限默认关闭,开启需通过邮箱 + 2FA + 人脸识别三重校验。 -
IP 白名单强制化:凡开启提现权限的 API Key,必须绑定 IP 白名单(最多 20 个),且不支持通配符。这与本文 3.6 节
ApiKeyService中的allowedIps校验逻辑一致。 -
Withdrawal Address Whitelist:除了 API Key 的 IP 白名单,提现目标地址也必须预先在 Web 端加入白名单。API 端发起的提现请求只能指向白名单地址,即使 API Key 泄露,资产也无法被转往陌生地址。
-
实时审计与熔断:大型加密货币交易所 的风控系统会对 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、CSRF | TLS 防窃听,不防服务端漏洞 |
| "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 存储 |
| 量化交易 API | API Key + HMAC-SHA256 + Nonce + Timestamp | OAuth2 授权码模式(太繁琐) |
| 第三方应用接入 | 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 本身包含自包含的声明,但生产环境中必须引入轻量级状态来实现吊销:
- 黑名单(Denylist):JWT 的
jti(JWT ID)作为唯一标识,登出/冻结时写入 Redis:SET jwt:blacklist:<jti> 1 EX <剩余过期时间>。每次验签时先查 Redis。 - 短有效期 + 刷新机制:Access Token 15 分钟, Refresh Token 轮换(每次使用 Refresh Token 后颁发新的 Refresh Token,旧的作废)。即使 Access Token 被盗,窗口期只有 15 分钟。
- 关键操作二次认证:对于提现、修改密码等高危操作,即使 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 导致通过。
防御措施:
- 白名单校验
alg:服务端硬编码允许的算法列表(如仅RS256),拒绝none/HS256/HS384等。 - 密钥隔离:RSA 的公钥和 HMAC 的 Secret 物理隔离,即使攻击者获取公钥也无法用于 HMAC。
- 使用成熟库:如 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: 防重放攻击中,如果客户端和服务端时钟不同步怎么办?
答:
- 允许容忍窗口:如本文 3.4 节所示,
TIMESTAMP_TOLERANCE_MS = 300000(5 分钟),覆盖绝大多数时钟漂移。 - 服务端返回时钟偏移:首次 API 调用返回
X-Server-Time响应头,客户端计算偏移量并在后续请求中自动校准。 - NTP 强制同步:在 API 文档中明确要求客户端必须启用 NTP 同步,并在 SDK 中内置 NTP 校准逻辑。
- 分级策略:对于读取类 API,允许更大的时间窗口(10 分钟);对于提现/转账等写操作,严格限制为 1 分钟,并要求客户端在请求前先做时间同步探测。
Q5: 为什么 SSRF 防御中不能仅做域名白名单,还必须解析 IP?
答:
DNS Rebinding(DNS 重绑定)攻击可以绕过纯域名白名单:
- 攻击者注册一个域名
evil.com,初始 DNS 指向1.2.3.4(公网 IP,在白名单外但可通过校验)。 - 服务端在校验域名时解析为
1.2.3.4,认为是公网地址,通过校验。 - 攻击者迅速修改 DNS 记录,将
evil.com指向10.0.0.1(内网地址)。 - 服务端实际发起 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)泄露,如何紧急止损?
答:
- 立即轮换密钥:使用备用密钥对(已预生成并安全存储),更新
kid指向新公钥。 - 全网推送 JWKS:确保所有服务节点在秒级获取到新公钥(使用配置中心如 Nacos/Consul 推送)。
- 旧 Token 批量吊销:遍历 Redis 中所有活跃用户会话,将旧 Key 签发的 Token
jti批量加入黑名单。 - 强制重新登录:对所有用户下发"会话失效"通知,要求重新输入密码 + 2FA。
- 根因排查:检查 HSM/KMS 访问日志、代码仓库提交记录、CI/CD 流水线日志,定位泄露源。
- 事后加固:缩短 Key 有效期(从 90 天改为 30 天),启用自动轮换(AWS KMS Automatic Rotation)。
最后提示(Interview Tip):
在 大型加密货币交易所 Risk 面试中,安全问题的回答务必体现出**"纵深防御(Defense in Depth)"**的思维——不要只谈某一个点的防御,而是要从输入层、传输层、会话层、应用层、数据层逐层展开。例如被问到"如何防止 SQL 注入"时,不仅要答 PreparedStatement,还要补充 WAF 规则、最小权限数据库账号、数据库审计日志、以及一旦注入后的响应预案(如蜜表、SQL 防火墙)。这种体系化的回答才能体现 Senior/Staff 级别的安全架构能力。