牛逼哄哄的前后端分离如何安全的鉴权

Posted 2021-04-30 爪哇笔记

 
   
   
 

  
    
    
  点击▲关注 “
  
    
    
  爪哇笔记
  
    
    
  ”   给公众号标星置顶
  
    
    
  

 
   
   
 
 
   
   
 

  
    
    
  更多精彩 第一时间直达
 
   
   
 

前言

阅读本文需要一定的前后端开发基础，前后端分离已成为互联网项目开发的业界标准使用方式，通过 nginx代理+Tomcat的方式有效的进行解耦，并且前后端分离会为以后的大型分布式架构、弹性计算架构、微服务架构、多端化服务（多种客户端，例如：浏览器，小程序，安卓，ios等等）打下坚实的基础。这个步骤是系统架构从猿进化成人的必经之路。

其核心思想是前端页面通过 AJAX调用后端的 API接口并使用 JSON数据进行交互。

原始模式

开发者通常使用 Servlet、Jsp、Velocity、Freemaker、Thymeleaf以及各种框架模板标签的方式实现前端效果展示。通病就是，后端开发者从后端撸到前端，前端只负责切切页面，修修图，更有甚者，一些团队都没有所谓的前端。

分离模式

在传统架构模式中，前后端代码存放于同一个代码库中，甚至是同一工程目录下。页面中还夹杂着后端代码。前后端分离以后，前后端分成了两个不同的代码库，通常使用  Vue、React、Angular、Layui等一系列前端框架实现。

权限校验

回到文章的主题，这里我们使用目前最流行的跨域认证解决方案 JSON Web Token（缩写  JWT）

pom.xml引入：

 
   
   
 

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

工具类，签发 JWT，可以存储简单的用户基础信息，比如用户ID、用户名等等，只要能识别用户信息即可，重要的角色权限不建议存储：

 
   
   
 

  
    
    
  /**
 * JWT加密和解密的工具类
 */
public class JwtUtils {
 /**
 * 加密字符串 禁泄漏
 */
 public static final String SECRET = "e3f4e0ffc5e04432a63730a65f0792b0";
 public static final int JWT_ERROR_CODE_NULL = 4000; // Token不存在
 public static final int JWT_ERROR_CODE_EXPIRE = 4001; // Token过期
 public static final int JWT_ERROR_CODE_FAIL = 4002; // 验证不通过

 /**
 * 签发JWT
 * @param id
 * @param subject
 * @param ttlMillis
 * @return String
 */
 public static String createJWT(String id, String subject, long ttlMillis) {
 SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
 long nowMillis = System.currentTimeMillis();
 Date now = new Date(nowMillis);
 SecretKey secretKey = generalKey();
 JwtBuilder builder = Jwts.builder()
 .setId(id)
 .setSubject(subject) // 主题
 .setIssuer("爪哇笔记") // 签发者
 .setIssuedAt(now) // 签发时间
 .signWith(signatureAlgorithm, secretKey); // 签名算法以及密匙
 if (ttlMillis >= 0) {
 long expMillis = nowMillis + ttlMillis;
 Date expDate = new Date(expMillis);
 builder.setExpiration(expDate); // 过期时间
 }
 return builder.compact();
 }
 /**
 * 验证JWT
 * @param jwtStr
 * @return CheckResult
 */
 public static CheckResult validateJWT(String jwtStr) {
 CheckResult checkResult = new CheckResult();
 Claims claims;
 try {
 claims = parseJWT(jwtStr);
 checkResult.setSuccess(true);
 checkResult.setClaims(claims);
 } catch (ExpiredJwtException e) {
 checkResult.setErrCode(JWT_ERROR_CODE_EXPIRE);
 checkResult.setSuccess(false);
 } catch (SignatureException e) {
 checkResult.setErrCode(JWT_ERROR_CODE_FAIL);
 checkResult.setSuccess(false);
 } catch (Exception e) {
 checkResult.setErrCode(JWT_ERROR_CODE_FAIL);
 checkResult.setSuccess(false);
 }
 return checkResult;
 }

 /**
 * 密钥
 * @return
 */
 public static SecretKey generalKey() {
 byte[] encodedKey = Base64.decode(SECRET);
 SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
 return key;
 }
 
 /**
 * 解析JWT字符串
 * @param jwt
 * @return
 * @throws Exception Claims
 */
 public static Claims parseJWT(String jwt) {
 SecretKey secretKey = generalKey();
 return Jwts.parser()
 .setSigningKey(secretKey)
 .parseClaimsJws(jwt)
 .getBody();
 }
}
 
   
   
 

验证实体信息：

 
   
   
 

  
    
    
  /**
 * 验证信息
 */
public class CheckResult {
 private int errCode;

 private boolean success;

 private Claims claims;

 public int getErrCode() {
 return errCode;
 }

 public void setErrCode(int errCode) {
 this.errCode = errCode;
 }

 public boolean isSuccess() {
 return success;
 }

 public void setSuccess(boolean success) {
 this.success = success;
 }

 public Claims getClaims() {
 return claims;
 }

 public void setClaims(Claims claims) {
 this.claims = claims;
 }
}
 
   
   
 

拦截访问配置，跨域访问设置以及请求拦截过滤：

 
   
   
 

  
    
    
  /**
 * 拦截访问配置
 */
@Configuration
public class SafeConfig implements WebMvcConfigurer {

 @Bean
 public SysInterceptor myInterceptor(){
 return new SysInterceptor();
 }

 @Override
 public void addCorsMappings(CorsRegistry registry) {
 registry.addMapping("/**")
 .allowedOrigins("*")
 .allowedMethods("GET", "HEAD", "POST", "PUT", "DELETE","OPTIONS")
 .allowCredentials(false).maxAge(3600);
 }
 @Override
 public void addInterceptors(InterceptorRegistry registry) {
 String[] patterns = new String[] { "/user/login","/*.html"};
 registry.addInterceptor(myInterceptor())
 .addPathPatterns("/**")
 .excludePathPatterns(patterns);
 }
}
 
   
   
 

拦截器统一权限校验：

 
   
   
 

  
    
    
  /**
 * 认证拦截器
 */
public class SysInterceptor implements HandlerInterceptor {
 
 private static final Logger logger = LoggerFactory.getLogger(SysInterceptor.class);
 
 @Autowired
 private SysUserService sysUserService;
 
 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
 Object handler){
 if (handler instanceof HandlerMethod){
 String authHeader = request.getHeader("token");
 if (StringUtils.isEmpty(authHeader)) {
 logger.info("验证失败");
 print(response,Result.error(JwtUtils.JWT_ERROR_CODE_NULL,"签名验证不存在，请重新登录"));
 return false;
 }else{
 CheckResult checkResult = JwtUtils.validateJWT(authHeader);
 if (checkResult.isSuccess()) {
 /**
 * 权限验证
 */
 String userId = checkResult.getClaims().getId();
 HandlerMethod handlerMethod = (HandlerMethod) handler;
 Annotation roleAnnotation= handlerMethod.getMethod().getAnnotation(RequiresRoles.class);
 if(roleAnnotation!=null){
 String[] role = handlerMethod.getMethod().getAnnotation(RequiresRoles.class).value();
 Logical logical = handlerMethod.getMethod().getAnnotation(RequiresRoles.class).logical();
 List<String> list = sysUserService.getRoleSignByUserId(Integer.parseInt(userId));
 int count = 0;
 for(int i=0;i<role.length;i++){
 if(list.contains(role[i])){
 count++;
 if(logical==Logical.OR){
 continue;
 }
 }
 }
 if(logical==Logical.OR){
 if(count==0){
 print(response,Result.error("无权限操作"));
 return false;
 }
 }else{
 if(count!=role.length){
 print(response,Result.error("无权限操作"));
 return false;
 }
 }
 }
 return true;
 } else {
 switch (checkResult.getErrCode()) {
 case SystemConstant.JWT_ERROR_CODE_FAIL:
 logger.info("签名验证不通过");
 print(response,Result.error(checkResult.getErrCode(),"签名验证不通过，请重新登录"));
 break;
 case SystemConstant.JWT_ERROR_CODE_EXPIRE:
 logger.info("签名过期");
 print(response,Result.error(checkResult.getErrCode(),"签名过期，请重新登录"));
 break;
 default:
 break;
 }
 return false;
 }
 }
 }else{
 return true;
 }
 }
 /**
 * 打印输出
 * @param response
 * @param message void
 */
 public void print(HttpServletResponse response,Object message){
 try {
 response.setStatus(HttpStatus.OK.value());
 response.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);
 response.setHeader("Cache-Control", "no-cache, must-revalidate");
 response.setHeader("Access-Control-Allow-Origin", "*");
 PrintWriter writer = response.getWriter();
 writer.write(JSONObject.toJSONString(message));
 writer.flush();
 writer.close();
 } catch (IOException e) {
 e.printStackTrace();
 }
 }
}
 
   
   
 

配置角色注解，可以直接把安全框架 Shiro的拷贝过来，如果有需要，菜单权限也可以配置上：

 
   
   
 

  
    
    
  /**
 * 权限注解
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RequiresRoles {

 /**
 * A single String role name or multiple comma-delimitted role names required in order for the method
 * invocation to be allowed.
 */
 String[] value();

 /**
 * The logical operation for the permission check in case multiple roles are specified. AND is the default
 * @since 1.1.0
 */
 Logical logical() default Logical.OR;
}
 
   
   
 

模拟演示代码：

 
   
   
 

  
    
    
  @RestController
@RequestMapping("/user")
public class UserController {
 /**
 * 列表
 * @return
 */
 @RequestMapping("/list")
 @RequiresRoles(value="admin")
 public Result list() {
 return Result.ok("十万亿个用户");
 }

 /**
 * 登录
 * @return
 */
 @RequestMapping("/login")
 public Result login() {
 /**
 * 模拟登录过程并返回token
 */
 String token = JwtUtils.createJWT("101","爪哇笔记",1000*60*60);
 return Result.ok(token);
 }
}
 
   
   
 

前端请求模拟，发送请求之前在 Header中附带 token信息，更多代码见源码案例：

 
   
   
 

  
    
    
  function login(){
 $.ajax({
 url : "/user/login",
 type : "post",
 dataType : "json",
 success : function(data) {
 if(data.code==0){
 $.cookie('token', data.msg);
 }
 },
 error : function(XMLHttpRequest, textStatus, errorThrown) {

 }
 });
}
function user(){
 $.ajax({
 url : "/user/list",
 type : "post",
 dataType : "json",
 success : function(data) {
 alert(data.msg)
 },
 beforeSend: function(request) {
 request.setRequestHeader("token", $.cookie('token'));
 },
 error : function(XMLHttpRequest, textStatus, errorThrown) {

 }
 });
}
  
    
    
  

 
   
   
 

安全说明

JWT 本身包含了认证信息，一旦泄露，任何人都可以获得该令牌的所有权限。为了减少盗用， JWT 的有效期建议设置的相对短一些。对于一些比较重要的权限，使用时应该再次对用户进行数据库认证。为了减少盗用， JWT 强烈建议使用  HTTPS 协议传输。

由于服务器不保存用户状态，因此无法在使用过程中注销某个  token，或者更改  token 的权限。也就是说，一旦  JWT 签发了，在到期之前就会始终有效，除非服务器部署额外的逻辑。

源码案例

https://gitee.com/52itstyle/safe-jwt

▲一个有温度的公众号，期待与你一起进步