其他分享
首页 > 其他分享> > 重学SpringCloud系列八之微服务网关安全认证-JWT篇

重学SpringCloud系列八之微服务网关安全认证-JWT篇

作者：互联网

重学SpringCloud系列八之微服务网关安全认证-JWT篇

Gateway-JWT认证鉴权流程

一、网关认证件鉴权流程

目前主流的结合微服务网关及JWT令牌开发用户认证及服务访问鉴权的流程如下：
img

令牌的颁发和校验需要基于同一个密钥，也就是说JWT 令牌的签名和解签必须有同一个密钥。谜面是"天王盖地虎"，谜底必须是“宝塔镇河妖”，如果密钥对不上则令牌的校验失败。

所以通常网关层面除了转发请求之外需要做两件事：一是校验JWT令牌的合法性，二是从JWT令牌中解析出用户身份，并在转发请求时携带用户身份信息。这样系统内的其他业务服务在收到转发请求的时候，根据用户的身份信息判断决定该用户可以访问哪些接口。

二、流程优化方案

从上面的流程中我们可以看出

也就是说这个JWT密钥相关的基础配置必须得在“认证服务”和“网关服务”上都配置一份，这样的配置分散不利于维护和密钥管理。所以我们优化一下流程：在gateway服务网关的服务上开发登录认证功能。优化后的流程如下：

img

三、学习本章内容需要具备的基础知识

从上面的流程看出，实现JWT认证鉴权流程其实并不是很复杂，但是要想真正的做好服务接口的鉴权流程，其涉及的基础知识还是非常多的。

3.1.在网关上实现登录认证

3.2. Spring Security基础

系统内的其他业务服务在收到转发请求的时候，根据用户的身份信息判断决定该用户可以访问哪些接口。该如何实现？你要有Spring Security的基础知识及RBAC权限管理模型相关的基础知识.

附录–上面的时序图代码

在线时序图编辑工具：https://www.websequencediagrams.com/

用户->+网关: 登录请求
网关-->-用户: return token


用户->+网关: 携带token访问业务
网关->网关: 校验token的合法性
网关->+其他服务: 携带用户身份信息转发请求
其他服务-->-网关: return data
网关-->-用户: return data

登录认证JWT令牌颁发

我们本节要实现的需求是：用户发起登录认证请求，网关服务上对该用户进行认证（用户名密码），认证成功之后将JWT令牌返回给用户客户端。
img
实现完成之后的项目结构如下：
img

一、maven核心依赖

在上一章代码的基础上，加上如下的一些maven依赖

<dependency>
   <groupId>io.jsonwebtoken</groupId>
   <artifactId>jjwt</artifactId>
   <version>0.9.0</version>
</dependency>

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

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.security</groupId>
   <artifactId>spring-security-crypto</artifactId>
</dependency>

<dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
   <optional>true</optional>
</dependency>

二、核心Controller

2个核心函数：

注意下文中的Mono是WebFlux结果响应数据回调的做法，不是我的自定义。

/**
 * JWT获取令牌和刷新令牌接口
 */
@RestController
@ConditionalOnProperty(name = "zimug.gateway.jwt.useDefaultController", havingValue = "true")
public class JwtAuthController {

    @Resource
    private JwtProperties jwtProperties;
    @Resource
    private SysUserRepository sysUserRepository;
    @Resource
    private JwtTokenUtil jwtTokenUtil;
    @Resource
    private PasswordEncoder passwordEncoder;

    /**
     * 使用用户名密码换JWT令牌
     */
    @RequestMapping("/authentication")
    public Mono<AjaxResponse> authentication(@RequestBody Map<String,String> map){
        //从请求体中获取用户名密码
        String username  = map.get(jwtProperties.getUserParamName());
        String password = map.get(jwtProperties.getPwdParamName());

        if(StringUtils.isEmpty(username)
                || StringUtils.isEmpty(password)){
            return buildErrorResponse("用户名或者密码不能为空");
        }
        //根据用户名（用户Id）去数据库查找该用户
        SysUser sysUser = sysUserRepository.findByUsername(username);
        if(sysUser != null){
            //将数据库的加密密码与用户明文密码match
            boolean isAuthenticated = passwordEncoder.matches(password,sysUser.getPassword());
            if(isAuthenticated){ //如果匹配成功
                //通过jwtTokenUtil生成JWT令牌并return
                return buildSuccessResponse(jwtTokenUtil.generateToken(username,null));
            } else{ //如果密码匹配失败
                return buildErrorResponse("请确定您输入的用户名或密码是否正确！");
            }
        }else{
            return buildErrorResponse("请确定您输入的用户名或密码是否正确！");
        }
    }

    /**
     * 刷新JWT令牌,用旧的令牌换新的令牌
     */
    @RequestMapping("/refreshtoken")
    public  Mono<AjaxResponse> refreshtoken(@RequestHeader("${zimug.gateway.jwt.header}") String oldToken){
        if(!jwtTokenUtil.isTokenExpired(oldToken)){
            return buildSuccessResponse(jwtTokenUtil.refreshToken(oldToken));
        }
        return Mono.empty();
    }

    private Mono<AjaxResponse> buildErrorResponse(String message){
       return Mono.create(callback -> callback.success( //请求结果成功的回调
            AjaxResponse.error( //响应信息是Error的,携带异常信息返回
                    new CustomException(CustomExceptionType.USER_INPUT_ERROR, message)
            )
       ));
    }

    private Mono<AjaxResponse> buildSuccessResponse(Object data){
        return Mono.create(callback -> callback.success( //请求结果成功的回调
                AjaxResponse.success(data)  //成功响应,携带数据返回
        ));
    }

}

四个核心服务代码类，后文会介绍

三、 JwtProperties

以下的这些配置属性，需要在gateway的配置文件中配置，不配置的话将使用默认值。

@Data
@ConfigurationProperties(prefix = "zimug.gateway.jwt")
@Component
public class JwtProperties {

    //是否开启JWT，即注入相关的类对象
    private Boolean enabled;
    //JWT密钥
    private String secret;
    //JWT有效时间
    private Long expiration;
    //前端向后端传递JWT时使用HTTP的header名称，前后端要统一
    private String header;
    //用户登录-用户名参数名称
    private String userParamName = "username";
    //用户登录-密码参数名称
    private String pwdParamName = "password";
    //是否使用默认的JWTAuthController
    private Boolean useDefaultController = false;

}
zimug:
  gateway:
    jwt:
      enabled: true   #是否开启JWT登录认证功能
      secret: fjkfaf;afa  # JWT私钥，用于校验JWT令牌的合法性
      expiration: 3600000 #JWT令牌的有效期，用于校验JWT令牌的合法性
      header: JWTHeaderName #HTTP请求的Header名称，该Header作为参数传递JWT令牌
      userParamName: username  #用户登录认证用户名参数名称
      pwdParamName: password  #用户登录认证密码参数名称
      useDefaultController: true # 是否使用默认的JwtAuthController

这些配置在代码中会影响程序的组件加载及运行逻辑，比如：当ConditionalOnProperty—zimug.gateway.jwt.useDefaultController=true的时候，才初始化JwtAuthController 这个类的Bean。这样做的目的是，我规划的gateway未来不仅支持JWT还支持OAuth，为了避免二者冲突或者冗余。我们加上开关去影响Bean的初始化行为。
img

四、SysUserRepository

SysUser 实体类对应数据库的sys_user表，遵循JPA规则定义

@Data
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name="sys_user")
public class SysUser {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private String username;

    @Column
    private String password;

    @Column
    private Integer orgId;

    @Column
    private Boolean enabled;

    @Column
    private String phone;

    @Column
    private String email;

    @Column
    private Date createTime;
}

根据sys_user表的username字段去查询SysUser用户信息。

public interface SysUserRepository extends JpaRepository<SysUser,Long> {

  //注意这个方法的名称，jPA会根据方法名自动生成SQL执行，完全不用自己写SQL
  SysUser findByUsername(String username);
}

需要在配置文件中加入jpa及数据源相关的配置

spring:
  datasource:
    url: jdbc:mysql://ip:3306/linnadb?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: 
    password: 
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: validate
    database: mysql
    show-sql: true

五、PasswordEncoder

我们需要通过PasswordEncoder进行密码的解签名校验，所以初始化一个Bean：BCryptPasswordEncoder。需要注意的是：我们使用BCryptPasswordEncoder.matches解签名的前提是，用户注册的时候存放到数据库里面的password也是经过BCryptPasswordEncoder.encode加密的。
img

六、JwtTokenUtil

基于io.jsonwebtoken-jjwt类库的代码封装，工具类。

@Component
public class JwtTokenUtil {

    @Resource
    private JwtProperties jwtProperties;


    /**
     * 生成token令牌
     *
     * @param userId 用户Id或用户名
     * @param payloads 令牌中携带的附加信息
     * @return 令token牌
     */
    public String generateToken(String userId,
                                Map<String,String> payloads) {
        int payloadSizes = payloads == null? 0 : payloads.size();

        Map<String, Object> claims = new HashMap<>(payloadSizes + 2);
        claims.put("sub", userId);
        claims.put("created", new Date());

        if(payloadSizes > 0){
            for(Map.Entry<String,String> entry:payloads.entrySet()){
                claims.put(entry.getKey(),entry.getValue());
            }
        }

        return generateToken(claims);
    }

    /**
     * 从令牌中获取用户名
     *
     * @param token 令牌
     * @return 用户名
     */
    public String getUsernameFromToken(String token) {
        String username;
        try {
            Claims claims = getClaimsFromToken(token);
            username = claims.getSubject();
        } catch (Exception e) {
            username = null;
        }
        return username;
    }

    /**
     * 判断令牌是否过期
     *
     * @param token 令牌
     * @return 是否过期
     */
    public Boolean isTokenExpired(String token) {
        try {
            Claims claims = getClaimsFromToken(token);
            Date expiration = claims.getExpiration();
            return expiration.before(new Date());
        } catch (Exception e) {
            //验证JWT签名失败等同于令牌过期
            return true;
        }
    }

    /**
     * 刷新令牌
     *
     * @param token 原令牌
     * @return 新令牌
     */
    public String refreshToken(String token) {
        String refreshedToken;
        try {
            Claims claims = getClaimsFromToken(token);
            claims.put("created", new Date());
            refreshedToken = generateToken(claims);
        } catch (Exception e) {
            refreshedToken = null;
        }
        return refreshedToken;
    }

    /**
     * 验证令牌
     *
     * @param token       令牌
     * @param userId  用户Id用户名
     * @return 是否有效
     */
    public Boolean validateToken(String token, String userId) {

        String username = getUsernameFromToken(token);
        return (username.equals(userId) && !isTokenExpired(token));
    }


    /**
     * 从claims生成令牌,如果看不懂就看谁调用它
     *
     * @param claims 数据声明
     * @return 令牌
     */
    private String generateToken(Map<String, Object> claims) {
        Date expirationDate = new Date(System.currentTimeMillis() + jwtProperties.getExpiration());
        return Jwts.builder().setClaims(claims)
                .setExpiration(expirationDate)
                .signWith(SignatureAlgorithm.HS512, jwtProperties.getSecret())
                .compact();
    }

    /**
     * 从令牌中获取数据声明,验证JWT签名
     *
     * @param token 令牌
     * @return 数据声明
     */
    private Claims getClaimsFromToken(String token) {
        Claims claims;
        try {
            claims = Jwts.parser().setSigningKey(jwtProperties.getSecret()).parseClaimsJws(token).getBody();
        } catch (Exception e) {
            claims = null;
        }
        return claims;
    }
}

七、访问测试

本机启动网关，进行http://127.0.0.1:8777/authentication登录认证，返回如下结果说明我们的实现是ok的。
img
测试令牌的刷新
img

全局过滤器实现JWT鉴权

img
在上一小节中我们已经实现了用户登录认证，用户如果认证成功后会返回给用户客户端一个令牌，也就是JWT。本节我们继续为大家介绍，当用户客户端再次访问网关的其他服务的时候，需要携带JWT，网关验证JWT的合法性，并从JWT中解析出用户身份信息转发出去。

一、全局过滤器实现JWT鉴权

对于网关的所有请求都要验证JWT的合法性（除了“/authentication”），所以使用Gateway全局过滤器 GlobalFilter就再合适不过了。在上一节代码基础上增加一个全局过滤器

@Configuration
public class JWTAuthCheckFilter {
  @Resource
  private JwtProperties jwtProperties;
  @Resource
  private JwtTokenUtil jwtTokenUtil;

  @Bean
  @Order(-101)
  public GlobalFilter jwtAuthGlobalFilter()
  {
    return (exchange, chain) -> {
      ServerHttpRequest serverHttpRequest = exchange.getRequest();
      ServerHttpResponse serverHttpResponse = exchange.getResponse();
      String requestUrl = serverHttpRequest.getURI().getPath();


      if(!requestUrl.equals("/authentication")){
        //从HTTP请求头中获取JWT令牌
        String jwtToken = serverHttpRequest
                .getHeaders()
                .getFirst(jwtProperties.getHeader());
         //对Token解签名，并验证Token是否过期
        boolean isJwtValid = jwtTokenUtil.isTokenExpired(jwtToken);
        if(isJwtNotValid){ //如果JWT令牌不合法
          return writeUnAuthorizedMessageAsJson(serverHttpResponse,"请先去登录，再访问服务！");
        }
        //从JWT中解析出当前用户的身份（userId），并继续执行过滤器链，转发请求
        ServerHttpRequest mutableReq = serverHttpRequest
                .mutate()
                .header("userId", jwtTokenUtil.getUsernameFromToken(jwtToken))
                .build();
        ServerWebExchange mutableExchange = exchange.mutate().request(mutableReq).build();
        return chain.filter(mutableExchange);
      }else{ //如果是登录认证请求，直接执行不需要进行JWT权限验证
        return chain.filter(exchange);
      }
    };
  }

  //将JWT鉴权失败的消息响应给客户端
  private Mono<Void> writeUnAuthorizedMessageAsJson(ServerHttpResponse serverHttpResponse,String message) {
    serverHttpResponse.setStatusCode(HttpStatus.UNAUTHORIZED);
    serverHttpResponse.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
    AjaxResponse ajaxResponse = AjaxResponse.error(CustomExceptionType.USER_INPUT_ERROR,message);
    DataBuffer dataBuffer = serverHttpResponse.bufferFactory()
            .wrap(JSON.toJSONStringWithDateFormat(ajaxResponse,JSON.DEFFAULT_DATE_FORMAT)
                    .getBytes(StandardCharsets.UTF_8));
    return serverHttpResponse.writeWith(Flux.just(dataBuffer));
  }

}

过滤器核心代码做了两件事

img
请结合上面的注释理解全局JWT鉴权的实现。如果理解有困难，结合下面的测试过程理解上面的代码。

二、测试

微服务自身内部的权限管理

一、再看流程

img
依照上面的流程，我们已经完成了

img
其他服务分为两种：

三、微服务内部的权限管理

已知：我们可以获得userId（用户身份信息），其他一概不知。我们可以使用RBAC权限模型管理用户权限。
img

最终服务内部通过userId（用户身份信息）获取到该用户能够访问的接口权限的列表X。用户正在访问的接口在X列表中，表示该用户可以访问该接口，否则无权限。

数据库模型

我们可以用下图中的数据库设计模型，描述这样的关系。

标签：网关,重学,return,String,SpringCloud,JWT,令牌,用户
来源： https://blog.csdn.net/m0_53157173/article/details/122821495