一、JWT Token 泄露的痛点

上周，一位做金融系统的朋友吐槽：他们的系统出现了用户账户被盗用的情况。

"用户反映自己的账户在异地登录，"朋友焦急地说，"我们使用了 JWT Token 进行身份认证，但无法检测到 Token 泄露，也无法强制下线已登录的设备。"

我查看了他们的代码，发现问题确实很严重：

• 使用标准 JWT Token 进行认证
• 没有 Token 状态管理机制
• 无法检测同一 Token 的多地登录
• 无法强制下线指定设备
• 没有 Token 泄露的告警机制

更关键的是，他们根本不知道有多少用户的 Token 被泄露，也无法及时采取措施保护用户账户安全。

二、传统方案的局限性

1. 标准 JWT Token

使用标准 JWT Token 进行认证。

@Component
public class JwtTokenProvider {
    
    @Value("${jwt.secret}")
    private String secret;
    
    @Value("${jwt.expiration}")
    private long expiration;
    
    public String createToken(String username) {
        Claims claims = Jwts.claims().setSubject(username);
        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + expiration);
        
        return Jwts.builder()
                .setClaims(claims)
                .setIssuedAt(now)
                .setExpiration(expiryDate)
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }
    
    public String getUsernameFromToken(String token) {
        Claims claims = Jwts.parser()
                .setSigningKey(secret)
                .parseClaimsJws(token)
                .getBody();
        return claims.getSubject();
    }
    
    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(secret).parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}

这种方案的问题：

• 无法撤销：Token 一旦签发，在过期前无法撤销
• 无法检测多地登录：无法知道同一 Token 是否在多个地方使用
• 无法强制下线：无法强制指定设备下线
• 无状态管理：服务端没有 Token 的状态管理
• 安全风险：Token 泄露后无法及时发现和处理

2. Redis 存储 Token

将 Token 存储在 Redis 中进行管理。

@Service
public class TokenService {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    private static final String TOKEN_PREFIX = "token:";
    
    public void storeToken(String username, String token) {
        redisTemplate.opsForValue().set(TOKEN_PREFIX + username, token);
    }
    
    public String getToken(String username) {
        return redisTemplate.opsForValue().get(TOKEN_PREFIX + username);
    }
    
    public void removeToken(String username) {
        redisTemplate.delete(TOKEN_PREFIX + username);
    }
    
    public boolean validateToken(String username, String token) {
        String storedToken = getToken(username);
        return storedToken != null && storedToken.equals(token);
    }
}

这种方案的问题：

• 单设备限制：只能允许一个设备登录，无法支持多设备
• 无法检测多地登录：只能检测 Token 是否匹配，无法检测多地登录
• 无设备管理：无法管理和区分不同设备
• 无告警机制：Token 泄露时无法及时告警
• 性能问题：每次请求都需要访问 Redis

3. Token 黑名单

使用 Token 黑名单机制处理已注销的 Token。

@Service
public class TokenBlacklistService {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    private static final String BLACKLIST_PREFIX = "blacklist:";
    
    public void addToBlacklist(String token, long expiration) {
        redisTemplate.opsForValue().set(BLACKLIST_PREFIX + token, "1", expiration, TimeUnit.MILLISECONDS);
    }
    
    public boolean isBlacklisted(String token) {
        return redisTemplate.hasKey(BLACKLIST_PREFIX + token);
    }
}

这种方案的问题：

• 被动处理：只能被动处理已注销的 Token
• 无法检测多地登录：无法主动检测 Token 泄露
• 无设备管理：无法管理和区分不同设备
• 无告警机制：Token 泄露时无法及时告警
• 存储压力：黑名单可能会变得很大

三、终极方案：JWT Token 泄露检测 + 设备管理

今天，我要和大家分享一个在实战中验证过的解决方案：JWT Token 泄露检测 + 设备管理。

这套方案的核心思想是：

1. 设备指纹：为每个登录设备生成唯一的设备指纹
2. Token 状态管理：在 Redis 中管理 Token 与设备的对应关系
3. 多地登录检测：检测同一 Token 在不同设备上的使用
4. 自动踢下线：发现 Token 泄露时自动踢下线异常设备
5. 多维度告警：Token 泄露时发送多渠道告警

四、方案详解

1. 核心原理

Token 泄露检测的工作流程如下：

用户登录
    ↓
生成设备指纹
    ↓
生成 JWT Token
    ↓
存储 Token 与设备的对应关系到 Redis
    ↓
返回 Token 给客户端
    ↓
用户请求携带 Token
    ↓
验证 Token 有效性
    ↓
提取设备指纹
    ↓
检查 Token 与设备的对应关系
    ↓
匹配 → 正常处理
不匹配 → 检测到 Token 泄露
    ↓
自动踢下线异常设备
    ↓
发送告警通知
    ↓
返回认证失败

2. SpringBoot实现

（1）设备指纹生成服务

@Service
public class DeviceFingerprintService {
    
    public String generateFingerprint(HttpServletRequest request) {
        StringBuilder fingerprint = new StringBuilder();
        
        // 客户端IP
        String clientIP = getClientIP(request);
        fingerprint.append(clientIP).append("|");
        
        // User-Agent
        String userAgent = request.getHeader("User-Agent");
        fingerprint.append(userAgent != null ? userAgent : "").append("|");
        
        // 浏览器信息
        String accept = request.getHeader("Accept");
        fingerprint.append(accept != null ? accept : "").append("|");
        
        // 编码为MD5
        return DigestUtils.md5DigestAsHex(fingerprint.toString().getBytes());
    }
    
    private String getClientIP(HttpServletRequest request) {
        String ip = request.getHeader("X-Forwarded-For");
        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }
}

（2）Token 管理服务

@Service
public class TokenManagerService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private static final String TOKEN_PREFIX = "token:";
    private static final String USER_PREFIX = "user:";
    private static final String DEVICE_PREFIX = "device:";
    
    public void storeTokenInfo(String username, String token, String deviceFingerprint, long expiration) {
        // 存储 Token 与设备的对应关系
        String tokenKey = TOKEN_PREFIX + token;
        TokenInfo tokenInfo = new TokenInfo(username, deviceFingerprint);
        redisTemplate.opsForValue().set(tokenKey, tokenInfo, expiration, TimeUnit.MILLISECONDS);
        
        // 存储用户的活跃 Token
        String userKey = USER_PREFIX + username;
        redisTemplate.opsForValue().set(userKey, token, expiration, TimeUnit.MILLISECONDS);
        
        // 存储设备信息
        String deviceKey = DEVICE_PREFIX + username + ":" + deviceFingerprint;
        redisTemplate.opsForValue().set(deviceKey, token, expiration, TimeUnit.MILLISECONDS);
    }
    
    public TokenInfo getTokenInfo(String token) {
        String tokenKey = TOKEN_PREFIX + token;
        return (TokenInfo) redisTemplate.opsForValue().get(tokenKey);
    }
    
    public String getUserToken(String username) {
        String userKey = USER_PREFIX + username;
        return (String) redisTemplate.opsForValue().get(userKey);
    }
    
    public String getDeviceToken(String username, String deviceFingerprint) {
        String deviceKey = DEVICE_PREFIX + username + ":" + deviceFingerprint;
        return (String) redisTemplate.opsForValue().get(deviceKey);
    }
    
    public void removeToken(String token) {
        TokenInfo tokenInfo = getTokenInfo(token);
        if (tokenInfo != null) {
            // 删除 Token 信息
            String tokenKey = TOKEN_PREFIX + token;
            redisTemplate.delete(tokenKey);
            
            // 删除设备信息
            String deviceKey = DEVICE_PREFIX + tokenInfo.getUsername() + ":" + tokenInfo.getDeviceFingerprint();
            redisTemplate.delete(deviceKey);
        }
    }
    
    public void removeUserTokens(String username) {
        String userKey = USER_PREFIX + username;
        String currentToken = (String) redisTemplate.opsForValue().get(userKey);
        if (currentToken != null) {
            removeToken(currentToken);
            redisTemplate.delete(userKey);
        }
    }
    
    public void removeDeviceToken(String username, String deviceFingerprint) {
        String deviceKey = DEVICE_PREFIX + username + ":" + deviceFingerprint;
        String token = (String) redisTemplate.opsForValue().get(deviceKey);
        if (token != null) {
            removeToken(token);
        }
    }
    
    @Data
    public static class TokenInfo {
        private String username;
        private String deviceFingerprint;
        
        public TokenInfo(String username, String deviceFingerprint) {
            this.username = username;
            this.deviceFingerprint = deviceFingerprint;
        }
    }
}

（3）JWT Token 提供器

@Component
public class JwtTokenProvider {
    
    @Value("${jwt.secret}")
    private String secret;
    
    @Value("${jwt.expiration}")
    private long expiration;
    
    public String createToken(String username, String deviceFingerprint) {
        Claims claims = Jwts.claims().setSubject(username);
        claims.put("deviceFingerprint", deviceFingerprint);
        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + expiration);
        
        return Jwts.builder()
                .setClaims(claims)
                .setIssuedAt(now)
                .setExpiration(expiryDate)
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }
    
    public String getUsernameFromToken(String token) {
        Claims claims = Jwts.parser()
                .setSigningKey(secret)
                .parseClaimsJws(token)
                .getBody();
        return claims.getSubject();
    }
    
    public String getDeviceFingerprintFromToken(String token) {
        Claims claims = Jwts.parser()
                .setSigningKey(secret)
                .parseClaimsJws(token)
                .getBody();
        return (String) claims.get("deviceFingerprint");
    }
    
    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(secret).parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}

（4）Token 泄露检测服务

@Service
public class TokenLeakDetectionService {
    
    @Autowired
    private TokenManagerService tokenManagerService;
    
    @Autowired
    private AlertService alertService;
    
    public boolean detectTokenLeak(String token, String deviceFingerprint) {
        TokenManagerService.TokenInfo tokenInfo = tokenManagerService.getTokenInfo(token);
        if (tokenInfo == null) {
            return false;
        }
        
        // 检查 Token 与设备指纹是否匹配
        if (!tokenInfo.getDeviceFingerprint().equals(deviceFingerprint)) {
            // 检测到 Token 泄露
            handleTokenLeak(tokenInfo.getUsername(), token, deviceFingerprint);
            return true;
        }
        
        return false;
    }
    
    private void handleTokenLeak(String username, String leakedToken, String suspiciousDevice) {
        // 1. 踢下线异常设备
        tokenManagerService.removeToken(leakedToken);
        
        // 2. 发送告警
        String message = String.format("Token leak detected for user %s from device %s", username, suspiciousDevice);
        alertService.sendAlert("Token Leak Detected", message);
        
        // 3. 记录日志
        log.warn("Token leak detected: user={}, device={}", username, suspiciousDevice);
    }
}

（5）认证过滤器

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    
    @Autowired
    private JwtTokenProvider tokenProvider;
    
    @Autowired
    private TokenManagerService tokenManagerService;
    
    @Autowired
    private TokenLeakDetectionService leakDetectionService;
    
    @Autowired
    private DeviceFingerprintService fingerprintService;
    
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String token = getJwtFromRequest(request);
        
        if (token != null && tokenProvider.validateToken(token)) {
            String username = tokenProvider.getUsernameFromToken(token);
            String tokenDeviceFingerprint = tokenProvider.getDeviceFingerprintFromToken(token);
            String currentDeviceFingerprint = fingerprintService.generateFingerprint(request);
            
            // 检测 Token 泄露
            if (leakDetectionService.detectTokenLeak(token, currentDeviceFingerprint)) {
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.getWriter().write("Token has been compromised");
                return;
            }
            
            // 验证 Token 是否在 Redis 中存在
            TokenManagerService.TokenInfo tokenInfo = tokenManagerService.getTokenInfo(token);
            if (tokenInfo == null) {
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.getWriter().write("Token has been invalidated");
                return;
            }
            
            // 创建认证对象
            UserDetails userDetails = // 从数据库获取用户信息
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                    userDetails, null, userDetails.getAuthorities());
            authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
            
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
        
        filterChain.doFilter(request, response);
    }
    
    private String getJwtFromRequest(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (bearerToken != null && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

（6）登录服务

@Service
public class AuthService {
    
    @Autowired
    private UserDetailsService userDetailsService;
    
    @Autowired
    private JwtTokenProvider tokenProvider;
    
    @Autowired
    private TokenManagerService tokenManagerService;
    
    @Autowired
    private DeviceFingerprintService fingerprintService;
    
    @Value("${jwt.expiration}")
    private long expiration;
    
    public AuthResponse login(String username, String password, HttpServletRequest request) {
        // 验证用户
        UserDetails userDetails = userDetailsService.loadUserByUsername(username);
        if (!passwordEncoder.matches(password, userDetails.getPassword())) {
            throw new BadCredentialsException("Invalid username or password");
        }
        
        // 生成设备指纹
        String deviceFingerprint = fingerprintService.generateFingerprint(request);
        
        // 生成 Token
        String token = tokenProvider.createToken(username, deviceFingerprint);
        
        // 存储 Token 信息
        tokenManagerService.storeTokenInfo(username, token, deviceFingerprint, expiration);
        
        return new AuthResponse(token, userDetails.getUsername());
    }
    
    public void logout(String token) {
        tokenManagerService.removeToken(token);
    }
    
    public void logoutAllDevices(String username) {
        tokenManagerService.removeUserTokens(username);
    }
    
    public void logoutDevice(String username, String deviceFingerprint) {
        tokenManagerService.removeDeviceToken(username, deviceFingerprint);
    }
    
    @Data
    public static class AuthResponse {
        private String token;
        private String username;
        
        public AuthResponse(String token, String username) {
            this.token = token;
            this.username = username;
        }
    }
}

（7）告警服务

@Service
public class AlertService {
    
    @Value("${alert.enabled:false}")
    private boolean enabled;
    
    @Value("${alert.email:}")
    private String email;
    
    @Value("${alert.webhook:}")
    private String webhook;
    
    public void sendAlert(String subject, String content) {
        if (!enabled) {
            return;
        }
        
        log.warn("ALERT - {}: {}", subject, content);
        
        if (email != null && !email.isEmpty()) {
            sendEmail(subject, content);
        }
        
        if (webhook != null && !webhook.isEmpty()) {
            sendWebhook(subject, content);
        }
    }
    
    private void sendEmail(String subject, String content) {
        // 发送邮件逻辑
    }
    
    private void sendWebhook(String subject, String content) {
        // 发送 webhook 逻辑
    }
}

3. 配置类

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Autowired
    private JwtAuthenticationFilter jwtAuthenticationFilter;
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .antMatchers("/api/auth/**").permitAll()
            .anyRequest().authenticated()
            .and()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
        
        http.addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

五、性能对比

1. 测试场景

• 并发用户数：1000
• 登录请求：500次/秒
• 普通请求：1000次/秒
• 测试时间：5分钟

2. 测试结果

六、最佳实践

1. 设备管理

• 设备指纹生成：使用多种客户端信息生成唯一的设备指纹
• 设备识别：识别常见设备类型（PC、手机、平板等）
• 设备管理界面：提供用户查看和管理已登录设备的界面
• 设备命名：允许用户为设备命名，便于识别

2. Token 管理

• 合理设置过期时间：根据业务需求设置合适的 Token 过期时间
• 刷新机制：实现 Token 刷新机制，避免用户频繁登录
• 批量操作：支持批量下线设备
• Token 版本控制：实现 Token 版本控制，支持滚动更新

3. 安全策略

• 多地登录策略：可配置是否允许多地登录
• 异常检测：检测异常登录行为（如异地登录、异常时间登录）
• 自动锁定：连续检测到 Token 泄露时自动锁定账户
• 密码重置：Token 泄露后强制用户重置密码

4. 监控告警

• 实时监控：实时监控 Token 泄露情况
• 多渠道告警：支持邮件、短信、webhook 等多种告警方式
• 告警级别：根据泄露严重程度设置不同的告警级别
• 历史记录：记录 Token 泄露的历史记录，便于分析

七、总结与展望

方案总结

1. Token 泄露检测：通过设备指纹检测 Token 泄露
2. 自动踢下线：发现 Token 泄露时自动踢下线异常设备
3. 多维度告警：支持多种告警方式，及时通知
4. 设备管理：支持管理和区分不同设备
5. 安全性高：大大提高了系统的安全性
6. 可扩展性强：易于扩展，支持更多的安全特性

未来优化方向

1. 机器学习：使用机器学习检测异常登录行为
2. 地理位置分析：分析登录地理位置，检测异常登录
3. 行为分析：分析用户行为模式，检测异常操作
4. 区块链集成：使用区块链技术存储 Token 状态，提高安全性
5. 生物识别：集成生物识别技术，提高认证安全性

技术价值

1. 提高安全性：有效检测和处理 Token 泄露
2. 保护用户账户：及时发现和处理账户异常
3. 提升用户体验：用户可以管理自己的登录设备
4. 降低安全风险：减少账户被盗用的风险
5. 符合合规要求：满足金融等行业的安全合规要求

八、写在最后

JWT Token 泄露是一个严重的安全问题，但通过设备指纹 + Token 状态管理方案，我们可以有效检测和处理 Token 泄露，保护用户账户安全。

当然，这套方案也不是银弹，它有以下局限性：

• 性能开销：每次请求都需要访问 Redis，增加了性能开销
• 存储压力：需要在 Redis 中存储 Token 状态，增加了存储压力
• 复杂度增加：系统复杂度增加，需要维护更多的组件
• 依赖 Redis：依赖 Redis 的可用性

但对于需要高安全性的系统，这套方案已经足够解决问题，而且稳定可靠。

希望这篇文章能给你带来一些启发，帮助你在实际项目中更好地处理 JWT Token 泄露的问题。

如果你在使用这套方案的过程中有其他经验或困惑，欢迎在评论区留言交流！

服务端技术精选，专注分享后端开发实战经验，让技术落地更简单。

如果你觉得这篇文章有用，欢迎点赞、在看、分享三连！