MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Spring Cloud 一次性 Token 使用指南

2022-01-313.8k 阅读

Spring Cloud 一次性 Token 使用指南

一、理解一次性 Token 的概念与应用场景

1.1 什么是一次性 Token

一次性 Token，也称为一次性口令（One - Time Password，OTP），是一种在特定场景下仅能使用一次的身份验证凭证。与传统的静态密码不同，一次性 Token 每次使用后即失效，极大地增强了安全性。在后端开发的微服务架构中，一次性 Token 常用于以下安全敏感操作，如用户登录、重要数据的访问授权、支付确认等环节。

1.2 应用场景分析

  • 增强登录安全性：传统的用户名密码登录方式存在密码泄露的风险。通过引入一次性 Token，用户在登录时除了提供用户名密码，系统还会发送一个一次性 Token 到用户的安全设备（如手机）上。用户输入该 Token 进行登录，即使密码被窃取，由于 Token 只能使用一次，攻击者也无法再次登录。
  • 保护重要数据访问：对于微服务中的关键数据，如用户的财务信息、医疗记录等，在每次访问时生成一次性 Token。只有持有有效一次性 Token 的请求才能访问数据，降低数据被非法访问的可能性。
  • 支付确认：在支付流程中，当用户确认支付时，系统生成一次性 Token 发送给用户。用户在支付页面输入该 Token，确保支付操作是由用户本人发起，防止支付欺诈。

二、Spring Cloud 中的一次性 Token 生成机制

2.1 使用 UUID 生成简单一次性 Token

在 Spring Cloud 项目中，可以利用 Java 的 UUID（通用唯一识别码）来生成简单的一次性 Token。UUID 具有全球唯一性，在一定程度上可以满足一次性 Token 的要求。

import java.util.UUID;

public class TokenGenerator {
    public static String generateToken() {
        return UUID.randomUUID().toString();
    }
}

上述代码通过 UUID.randomUUID().toString() 方法生成一个随机的 UUID 字符串作为一次性 Token。然而，这种方式生成的 Token 没有时效性限制，需要额外的机制来管理其有效期。

2.2 基于时间的一次性密码（TOTP）生成

更常用的方式是基于时间的一次性密码（Time - based One - Time Password，TOTP）。TOTP 是一种根据当前时间生成一次性密码的算法。它依赖于一个共享密钥（secret key）和时间戳来生成密码。在 Spring Cloud 中，可以借助第三方库如 google - authenticator 来实现 TOTP。 首先，添加依赖：

<dependency>
    <groupId>com.warrenstrange</groupId>
    <artifactId>google - authenticator</artifactId>
    <version>1.2.0</version>
</dependency>

然后，编写生成 TOTP Token 的代码：

import com.warrenstrange.googleauth.GoogleAuthenticator;
import com.warrenstrange.googleauth.GoogleAuthenticatorKey;
import com.warrenstrange.googleauth.GoogleAuthenticatorQRGenerator;

public class TOTPTokenGenerator {
    private static final int SECRET_KEY_LENGTH = 20;
    private static final int CODE_DIGITS = 6;

    public static String generateSecretKey() {
        GoogleAuthenticatorKey key = GoogleAuthenticatorKey.builder()
               .setKeyLength(SECRET_KEY_LENGTH)
               .build();
        return key.getKey();
    }

    public static String generateTOTP(String secretKey) {
        GoogleAuthenticator gAuth = new GoogleAuthenticator();
        gAuth.setCodeDigits(CODE_DIGITS);
        return gAuth.getTotpPassword(secretKey);
    }

    public static String generateQRCode(String secretKey, String account, String issuer) {
        return GoogleAuthenticatorQRGenerator.getOtpAuthUrl(issuer, account, secretKey);
    }
}

在上述代码中，generateSecretKey 方法生成一个共享密钥，generateTOTP 方法根据共享密钥生成当前时间的 TOTP Token，generateQRCode 方法生成用于在手机认证器（如 Google Authenticator）中设置密钥的 QR 码链接。

三、一次性 Token 的存储与管理

3.1 基于内存的存储

在开发和测试阶段，可以使用基于内存的存储方式来管理一次性 Token。例如，使用 Java 的 ConcurrentHashMap。

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class InMemoryTokenStore {
    private static final Map<String, Long> tokenStore = new ConcurrentHashMap<>();

    public static void storeToken(String token, long expirationTime) {
        tokenStore.put(token, expirationTime);
    }

    public static boolean isValidToken(String token) {
        Long expirationTime = tokenStore.get(token);
        if (expirationTime == null) {
            return false;
        }
        return System.currentTimeMillis() < expirationTime;
    }

    public static void removeToken(String token) {
        tokenStore.remove(token);
    }
}

上述代码实现了一个简单的基于内存的 Token 存储。storeToken 方法将 Token 及其过期时间存储到 ConcurrentHashMap 中，isValidToken 方法检查 Token 是否有效，removeToken 方法在 Token 使用后将其从存储中移除。然而，这种方式在生产环境中存在局限性，因为当应用重启时，存储的 Token 会丢失。

3.2 使用 Redis 存储

在生产环境中，推荐使用 Redis 来存储一次性 Token。Redis 具有高性能、支持数据持久化以及分布式特性，非常适合在微服务架构中管理 Token。 首先，添加 Spring Data Redis 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring - boot - starter - data - redis</artifactId>
</dependency>

然后，配置 Redis 连接：

spring:
  redis:
    host: your - redis - host
    port: 6379
    password: your - password

接着，编写 Redis 存储 Token 的代码：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

@Component
public class RedisTokenStore {
    private static final String TOKEN_PREFIX = "token:";
    @Autowired
    private RedisTemplate<String, Long> redisTemplate;

    public void storeToken(String token, long expirationTime) {
        redisTemplate.opsForValue().set(TOKEN_PREFIX + token, expirationTime, expirationTime, TimeUnit.MILLISECONDS);
    }

    public boolean isValidToken(String token) {
        Long expirationTime = redisTemplate.opsForValue().get(TOKEN_PREFIX + token);
        if (expirationTime == null) {
            return false;
        }
        return System.currentTimeMillis() < expirationTime;
    }

    public void removeToken(String token) {
        redisTemplate.delete(TOKEN_PREFIX + token);
    }
}

在上述代码中，storeToken 方法将 Token 及其过期时间存储到 Redis 中，isValidToken 方法检查 Token 是否有效，removeToken 方法在 Token 使用后从 Redis 中删除该 Token。

四、在微服务接口中使用一次性 Token 进行身份验证

4.1 定义 Token 验证过滤器

在 Spring Cloud 微服务中，可以通过定义一个过滤器来验证传入请求中的一次性 Token。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class TokenAuthenticationFilter extends OncePerRequestFilter {
    @Autowired
    private TokenStore tokenStore;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String token = request.getHeader("Authorization");
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            if (tokenStore.isValidToken(token)) {
                filterChain.doFilter(request, response);
                tokenStore.removeToken(token);
                return;
            }
        }
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
    }
}

上述过滤器从请求头中获取 Token，验证其有效性。如果 Token 有效，则放行请求并在请求处理后移除 Token；如果 Token 无效，则返回 401 未授权状态码。

4.2 配置过滤器

在 Spring Boot 应用中，需要将上述过滤器配置到 Spring 过滤器链中。

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {
    @Bean
    public FilterRegistrationBean<TokenAuthenticationFilter> tokenAuthenticationFilterFilterRegistrationBean() {
        FilterRegistrationBean<TokenAuthenticationFilter> registrationBean = new FilterRegistrationBean<>();
        TokenAuthenticationFilter tokenAuthenticationFilter = new TokenAuthenticationFilter();
        registrationBean.setFilter(tokenAuthenticationFilter);
        registrationBean.addUrlPatterns("/protected/*");
        return registrationBean;
    }
}

在上述配置中，将 TokenAuthenticationFilter 过滤器映射到 /protected/* 路径下，表示只有访问该路径下的接口时才需要进行 Token 验证。

五、处理一次性 Token 的过期与重发

5.1 Token 过期处理

当一次性 Token 过期时，需要向用户返回适当的错误信息。在 Token 验证过滤器中，可以添加更详细的错误处理逻辑。

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class TokenAuthenticationFilter extends OncePerRequestFilter {
    @Autowired
    private TokenStore tokenStore;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String token = request.getHeader("Authorization");
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            if (tokenStore.isValidToken(token)) {
                filterChain.doFilter(request, response);
                tokenStore.removeToken(token);
                return;
            } else {
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
                response.setContentType(MediaType.APPLICATION_JSON_VALUE);
                Map<String, String> error = new HashMap<>();
                error.put("message", "Token has expired");
                new ObjectMapper().writeValue(response.getOutputStream(), error);
            }
        } else {
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            response.setContentType(MediaType.APPLICATION_JSON_VALUE);
            Map<String, String> error = new HashMap<>();
            error.put("message", "Token is missing");
            new ObjectMapper().writeValue(response.getOutputStream(), error);
        }
    }
}

上述代码在 Token 过期时，返回一个包含错误信息的 JSON 响应。

5.2 Token 重发机制

当用户的一次性 Token 过期或丢失时，需要提供一种重发机制。这可以通过在用户界面提供一个“重新获取 Token”的按钮来实现。后端接口在接收到重发请求时，重新生成一次性 Token 并发送给用户。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TokenController {
    @Autowired
    private TokenGenerator tokenGenerator;
    @Autowired
    private TokenSender tokenSender;

    @GetMapping("/resendToken")
    public ResponseEntity<String> resendToken(@RequestParam String userId) {
        String newToken = tokenGenerator.generateToken();
        tokenSender.sendToken(userId, newToken);
        return new ResponseEntity<>(newToken, HttpStatus.OK);
    }
}

在上述代码中，/resendToken 接口接收用户 ID，重新生成一次性 Token 并通过 tokenSender 发送给用户。

六、安全性考量与优化

6.1 防止暴力破解

一次性 Token 虽然每次使用后即失效，但仍需防止攻击者通过暴力破解的方式获取有效的 Token。对于基于 TOTP 的 Token，由于其生成依赖于共享密钥和时间戳，攻击者难以通过暴力破解获取正确的 Token。然而，对于简单的 UUID 生成的 Token，建议增加 Token 的长度，降低暴力破解的可能性。同时，可以在系统中设置登录失败次数限制，当连续失败次数达到一定阈值时，暂时锁定用户账号或增加验证难度。

6.2 密钥管理

在生成一次性 Token 的过程中，密钥的管理至关重要。对于基于 TOTP 的 Token，共享密钥必须安全存储，避免泄露。可以使用加密技术对密钥进行加密存储，只有在生成 Token 时才进行解密。同时，定期更换共享密钥，以增强系统的安全性。

6.3 网络传输安全

一次性 Token 在网络传输过程中，必须保证其安全性。建议使用 HTTPS 协议进行传输，对 Token 进行加密处理，防止中间人攻击窃取 Token。在微服务内部通信中，也可以采用类似的加密机制，确保 Token 在不同服务之间传递时的安全性。

6.4 审计与日志记录

对一次性 Token 的使用进行审计和日志记录是保障系统安全的重要手段。记录每次 Token 的生成、使用、过期等操作，以便在出现安全问题时能够进行追溯和分析。同时，通过对日志的分析，可以发现异常的 Token 使用模式，及时采取措施防范安全风险。

七、与其他认证机制的结合使用

7.1 与 OAuth2 结合

在 Spring Cloud 微服务架构中，一次性 Token 可以与 OAuth2 认证机制结合使用。OAuth2 主要用于授权第三方应用访问资源，而一次性 Token 可以作为额外的安全层，增强用户身份验证的安全性。例如，在 OAuth2 的授权码模式中，当用户授权第三方应用访问资源时，可以同时生成一次性 Token 发送给用户。用户在将授权码交换为访问令牌时，需要提供一次性 Token 进行验证，从而提高整个授权流程的安全性。

7.2 与 JWT 结合

JSON Web Token（JWT）是一种常用的身份验证和授权机制。可以将一次性 Token 与 JWT 结合使用，在 JWT 的 payload 中添加一次性 Token 的相关信息，如 Token 的生成时间、过期时间等。在验证 JWT 的同时，验证一次性 Token 的有效性。这样可以充分利用 JWT 的分布式特性和一次性 Token 的一次性使用特性，提高系统的安全性和灵活性。

7.3 多因素认证集成

一次性 Token 可以作为多因素认证（Multi - Factor Authentication，MFA）的一部分。除了用户名密码之外，用户还需要提供一次性 Token 进行身份验证。例如，在登录过程中，用户输入用户名密码后，系统发送一次性 Token 到用户的手机，用户输入该 Token 完成登录。这种方式结合了用户知道的信息（密码）和用户拥有的设备（手机），大大增强了认证的安全性。

八、性能优化与扩展性

8.1 缓存优化

在处理一次性 Token 时，缓存机制可以显著提高性能。如前面提到的使用 Redis 存储 Token，Redis 的缓存特性可以快速处理 Token 的存储、查询和删除操作。此外，可以对一些常用的 Token 验证逻辑进行缓存，减少重复计算。例如，对于同一用户在短时间内多次请求验证相同类型的 Token，可以将验证结果缓存起来，直接返回缓存结果，提高响应速度。

8.2 分布式处理

在微服务架构中，一次性 Token 的生成、存储和验证可能分布在多个服务节点上。为了确保系统的扩展性，需要采用分布式的解决方案。例如，使用分布式缓存（如 Redis Cluster）来存储 Token，保证在多节点环境下 Token 存储的一致性和高可用性。在生成 Token 时，可以采用分布式算法，确保在不同节点上生成的 Token 具有唯一性和一致性。

8.3 异步处理

对于一些耗时的操作，如 Token 的发送（例如通过短信或邮件发送一次性 Token），可以采用异步处理的方式。使用消息队列（如 RabbitMQ、Kafka 等）将发送任务异步化，避免阻塞主线程，提高系统的整体性能和响应速度。同时，异步处理还可以提高系统的容错性，即使发送过程中出现问题，也不会影响其他业务流程的正常运行。