重学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://www.websequencediagrams.com/
用户->+网关: 登录请求
网关-->-用户: 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的范畴,我就不带着大家一一讲解实现了。