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

大大的周 02-07 6278

重学SpringCloud系列八之微服务网关安全认证-JWT篇 Gateway-JWT认证鉴权流程一、网关认证件鉴权流程二、流程优化方案三、学习本章内容需要具备的基础知识3.1.在网关上实现登录认证3.2. Spring Security基础附录--上面的时序图代码登录认证JWT令牌颁发一、maven核心依赖二、核心Controller三、 JwtProperties四、SysUserRepository五、PasswordEncoder六、JwtTokenUtil七、访问测试全局过滤器实现JWT鉴权一、全局过滤器实现JWT鉴权二、测试微服务自身内部的权限管理一、再看流程三、微服务内部的权限管理数据库模型

Gateway-JWT认证鉴权流程一、网关认证件鉴权流程

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

用户认证流程：用户向网关发送登录认证请求，网关将请求转发给认证服务。认证服务校验用户登录信息（用户密码、短信及图片验证码）等信息之后，如果校验成功颁发一个token令牌给该用户（这个令牌可以是JWT令牌）网关级别访问鉴权：当用户访问系统内的其他业务服务接口时，需要携带登录认证的时候颁发的JWT token。网关验证JWT token的合法性，如果token不合法，则返回接口访问权限不足。如果token合法，则将请求按照网关的路由规则转发至相应的服务。服务级别访问鉴权：网关级别的访问鉴权只是鉴别了JWT令牌的合法性，初步认定你是这个系统的用户，但是作为系统的用户并不意味着你可以访问所有的服务接口。通常基于用户的角色分类有更严格的访问权限划分。

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

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

二、流程优化方案

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

令牌的颁发是由认证服务完成的令牌的校验是由网关完成的

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

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

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

3.1.在网关上实现登录认证因为gateway网关的基础框架是Spring WebFlux，不是Spring MVC。所以你需要有一定的WebFlux开发知识。Spring WebFlux对于关系型数据库的响应式编程目前的支持非常有限。笔者多次试验mybatis目前肯定是不能用了，JPA兼容性比较好。所以你要有JPA的知识。（WebFlux不支持MysQL数据库访问的响应式编程，不等于它不支持MySQL，还是可以使用MYSQL数据库的） 3.2. Spring Security基础

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

附录–上面的时序图代码

在线时序图编辑工具：https://·/

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

登录认证JWT令牌颁发

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

一、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> jjwt是实现JWT 令牌的核心类库spring-boot-starter-data-jpa是持久层框架，因为我们需要去数据库加载用户信息。之所以不用mybatis，因为webFlux下mybatis目前兼容性不好。spring-security-crypto是Spring 框架下进行加密解密、加签解签操作的常用类库二、核心Controller

2个核心函数：

authentication实现登录认证，认证成功之后返回JWT令牌refreshtoken实现令牌刷新，使用旧的令牌换取新的令牌（因为JWT令牌是有有效期的，超过有效期令牌非法）

注意下文中的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，JWT配置加载类，包含JWT密钥配置、过期时间等参数配置SysUserRepository，数据库sys_user表对应的JPA Repository。因为该表是用户信息表，包含用户名密码。JwtTokenUtil，JWT令牌操作工具封装类。核心方法如：根据用户id生成JWT令牌，校验令牌合法性，刷新令牌等工具类PasswordEncoder，是Spring Security的加解密工具类。核心方法是encode用于密码加密；matches用于密码校验。（在用户注册的时候用encode加密，在用户登录认证的时候用matches进行密码校验）三、 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的初始化行为。

四、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加密的。

六、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的。测试令牌的刷新

全局过滤器实现JWT鉴权

在上一小节中我们已经实现了用户登录认证，用户如果认证成功后会返回给用户客户端一个令牌，也就是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)); } }

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

验证JWT的合法性，对于不合法请求直接返回，不予转发。对于JWT合法的情况，从JWT中解析出userId（用户身份信息），并放入HTTP header中。（网关后面的服务会用到，下一节）

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

二、测试不携带JWT token访问http://127.0.0.1:8777/sysuser/pwd/reset。去登陆http://127.0.0.1:8777/authentication,得到JWT令牌将JWT令牌添加到http://127.0.0.1:8777/sysuser/pwd/reset访问请求的Header中，再次发起请求结果如下我们随便修改一下JWT令牌字符串，再次访问http://127.0.0.1:8777/sysuser/pwd/reset，结果如下：

微服务自身内部的权限管理一、再看流程

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

在网关上开发登录认证的功能，用户登录认证后返回给客户端JWT令牌在网关上新建了全局过滤器，当有请求发送到网关后，该过滤器校验JWT令牌的合法性。只有令牌合法请求才会被转发到具体的业务服务。并且在过滤器中我们在JWT令牌中解析出userId（用户身份信息），并向网关后面的服务传递。

其他服务分为两种：

一种服务是对系统内所有的用户开放，即：用户通过了网关的JWT鉴权，服务自身就不再对用户进行权限限制，所有的接口都可以被访问。另一种服务是自己有权限要求，比如根据角色来判断你是否具有访问某些接口的权限。比如：作为系统管理员用户，你可以访问“系统日志”、“系统管理”等功能接口；作为系统的操作员，你只能访问一些业务操作接口。三、微服务内部的权限管理

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

根据userId查询可以得到用户信息根据用户信息可以查询到角色信息（一个用户有多个角色）根据角色信息可以查到接口权限信息（一个角色有多个权限）

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

数据库模型

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

一个用户有一个或多个角色一个角色包含多个用户一个角色有多种权限一个权限属于多个角色 sys_user是用户信息表，用于存储用户的基本信息，如：用户名、密码sys_role是角色信息表，用于存储系统内所有的角色sys_menu是系统的菜单信息表，用于存储系统内所有的菜单。用id与父id的字段关系维护一个菜单树形结构。sys_user_role是用户角色多对多关系表，一条userid与roleid的关系记录表示该用户具有该角色，该角色包含该用户。sys_role_menu是角色菜单(权限)关系表，一条roleid与menuid的关系记录表示该角色由某菜单权限，该菜单权限可以被某角色访问。这个过程你可以结合Spring Security去实现，也可以结合shiro去实现，或者不用任何框架自己去判断实现都可以。微服务内部的权限管理的知识已经超出了Spring Cloud的范畴，我就不带着大家一一讲解实现了。