JWT的token认证

JSON Web Token（JWT）是一个非常轻巧的规范。这个规范允许我们使用JWT在用户和服务器之间传递安全可靠的信息
 
一个JWT实际上就是一个字符串，它由三部分组成，头部、载荷与签名。
头部（Header）
 头部用于描述关于该JWT的最基本的信息，例如其类型以及签名所用的算法等。这也可以 被表示成一个JSON对象。
   {"typ":"JWT","alg":"HS256"}
在头部指明了签名算法是HS256算法。 我们进行BASE64编 码，
编码后的字符串如下： 
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9

  载荷（playload）


  载荷就是存放有效信息的地方。这个名字像是特指飞机上承载的货品，这些有效信息包含三个部分




（1）标准中注册的声明（建议但不强制使用）




    iss: jwt签发者




    sub: jwt所面向的用户




    aud: 接收jwt的一方




    exp: jwt的过期时间，这个过期时间必须要大于签发时间




    nbf: 定义在什么时间之前，该jwt都是不可用的.




    iat: jwt的签发时间




      jti: jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击。




（2）公共的声明




   公共的声明可以添加任何的信息，一般添加用户的相关信息或其他业务需要的必要信息.但不建议添加敏感信息，因为该部分在客户端可解密.




（3）私有的声明




   私有声明是提供者和消费者所共同定义的声明，一般不建议存放敏感信息，因为base64是对称解密的，意味着该部分信息可以归类为明文信息。




    这个指的就是自定义的claim。比如前面那个结构举例中的admin和name都属于自定的claim。这些claim跟JWT标准规定的claim区别在于：JWT规定的claim，JWT的接收方在拿到JWT之后，都知道怎么对这些标准的claim进行验证(还不知道是否能够验证)；而




private claims不会验证，除非明确告诉接收方要对这些claim进行验证以及规则才行。




  定义一个payload:




    {"sub":"1234567890","name":"John Doe","admin":true}




    然后将其进行base64编码，得到Jwt的第二部分。




    eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9




签证（signature）




     jwt的第三部分是一个签证信息，这个签证信息由三部分组成：




     header (base64后的)




     payload (base64后的)




      secret




      这个部分需要base64加密后的header和base64加密后的payload使用.连接组成的字符串，然后通过header中声明的加密方式进行加盐secret组合加密，然后就构成了jwt的第三部分。


     TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ




将这三部分用.连接成一个完整的字符串,构成了最终的jwt:




eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ




注意：secret是保存在服务器端的，jwt的签发生成也是在服务器端的，secret就是用来进行jwt的签发和jwt的验证，所以，它就是你服务端的私钥，在任何场景都不应该流露出去。一旦客户端得知这个secret, 那就意味着客户端是可以自我签发jwt了。




 


  Java的JJWT实现JWT


 


  引入依赖 







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




  




//生成token
JwtBuilder builder= Jwts.builder().setId("111") 
         .setSubject("test") 
　　　　　 .setIssuedAt(new Date()) //签发时间 
         .signWith(SignatureAlgorithm.HS256,"testsign");  //签名秘钥
 System.out.println( builder.compact() )



  每次结果是不一样的，因为我们的载荷中包含了时间。




  




String token="eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiI4ODgiLCJzdWIiOiLlsI_nmb0iLCJpYXQiO jE1MjM0MTM0NTh9.gq0J‐cOM_qCNqU_s‐d_IrRytaNenesPmqAIhQpYXHZk";
//claims相当于一个map集合 
Claims claims = Jwts.parser().setSigningKey("testsign").parseClaimsJws(token).getBody(); 
  System.out.println("id:"+claims.getId());
  System.out.println("subject:"+claims.getSubject());
  System.out.println("IssuedAt:"+claims.getIssuedAt()); }






 过期时间校验 


 




//为了方便测试，我们将过期时间设置为1分钟
 long now = System.currentTimeMillis();//当前时间
 long exp = now + 1000*60;//过期时间为1分钟 
 JwtBuilder builder= Jwts.builder().setId("111") 
　　　　.setSubject("test") 
       .setIssuedAt(new Date()) 
       .signWith(SignatureAlgorithm.HS256,"testsign") 
       .setExpiration(new Date(exp)); //过期时间
    System.out.println( builder.compact() );



//校验 


Claims claims =Jwts.parser().setSigningKey("testsign").parseClaimsJws(token).getBody();


　　　　System.out.println("id:"+claims.getId());


　　　　System.out.println("subject:"+claims.getSubject());


　　　　SimpleDateFormat sdf=new SimpleDateFormat("yyyy‐MM‐dd hh:mm:ss");


　　　　System.out.println("签发时间:"+sdf.format(claims.getIssuedAt()));


　　　　System.out.println("过期时间:"+sdf.format(claims.getExpiration()));


　　　　System.out.println("当前时间:"+sdf.format(new Date()) );


 


 




当过期时会引发io.jsonwebtoken.ExpiredJwtException异常  需要try catch 捕获


 






 


自定义claims


   




//为了方便测试，我们将过期时间设置为1分钟
 long now = System.currentTimeMillis();//当前时间
 long exp = now + 1000*60;//过期时间为1分钟 
 JwtBuilder builder= Jwts.builder().setId("111") 
　　　　.setSubject("test") 
       .setIssuedAt(new Date()) 
       .signWith(SignatureAlgorithm.HS256,"testsign") 
       .setExpiration(new Date(exp)); //过期时间
       .claim("roles","admin")  //自定义claim
       .claim("logo","logo.png");


    System.out.println( builder.compact() );

//获取使用 claims.get（）


   System.out.println("roles:"+claims.get("roles"));


   System.out.println("logo:"+claims.get("logo"));








   


JWT 工具类  


 




@ConfigurationProperties("jwt.config")
 public class JwtUtil   { 
 private String key ; 
 private long ttl ;//一个小时
 public String getKey() {
     return key;
 }
public void setKey(String key) { 

    this.key = key; 
}
public long getTtl() {
 return ttl;
 }
public void setTtl(long ttl) {
 this.ttl = ttl; 
}

/*** 生成JWT ** @param id * @param subject * @return */ 

public String createJWT(String id, String subject, String roles) //自行配置参数
{ 
   long nowMillis = System.currentTimeMillis();
   Date now = new Date(nowMillis); 
   JwtBuilder builder = Jwts.builder().setId(id)
    .setSubject(subject) 
    .setIssuedAt(now)
    .signWith(SignatureAlgorithm.HS256, key)
    //.claim("roles", roles);
   if (ttl > 0) {
     builder.setExpiration( new Date( nowMillis + ttl));  
   }


     return builder.compact();


}


/**


* 解析JWT


* @param jwtStr


* @return


*/


public Claims parseJWT(String jwtStr){


    return Jwts.parser()


           .setSigningKey(key)


           .parseClaimsJws(jwtStr)


           .getBody();


}


}




application.yml, 添加配置






jwt:
  config: 
     key: testscret
     ttl: 360000 //1小时








@Bean   //注入bean容器 
public JwtUtil jwtUtil(){ 
   return new util.JwtUtil();
 }




 




 


使用拦截器 实现token鉴权 


 创建拦截器类 




@Component
public class JwtInterceptor implements HandlerInterceptor{
    @Autowired
    private JwtUtil jwtUtil;

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    //无论如何都放行。具体能不能操作还是在具体的操作中去判断。
        //拦截器只是负责把头请求头中包含token的令牌进行一个解析验证。
        String header = request.getHeader("Authorization"); 

        if(header!=null && !"".equals(header)){
            //如果有包含有Authorization头信息，就对其进行解析  
            if(header.startsWith("Bearer ")){  //对token进行混淆
                //得到token
                String token = header.substring(7);
                //对令牌进行验证
                try {
                    Claims claims = jwtUtil.parseJWT(token);
                    String roles = (String) claims.get("roles");
                    if(roles!=null && roles.equals("admin")){
                        request.setAttribute("claims_admin", token);   //放入request中 给control处理
                    }
                    if(roles!=null && roles.equals("user")){
                        request.setAttribute("claims_user", token);
                    }
                }catch (Exception e){
                    throw new RuntimeException("令牌不正确！");
                }
            }
        }
        return true;
    }
}




配置拦截器类 




@Configuration
public class InterceptorConfig extends WebMvcConfigurationSupport {

    @Autowired
    private JwtInterceptor jwtInterceptor;

    protected void addInterceptors(InterceptorRegistry registry) {
        //注册拦截器要声明拦截器对象和要拦截的请求
        registry.addInterceptor(jwtInterceptor)
                .addPathPatterns("/**") //拦截路径 
                .excludePathPatterns("/**/login/**");  //不拦截路径
    }
}




 




//业务层验证令牌
Claims claims=(Claims)request.getAttribute("user_claims"); 
if(claims==null){ 
  return new Result(false,StatusCode.ACCESSERROR,"无权访问");
}




 


 


安全配置类 




@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter{
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //authorizeRequests所有security全注解配置实现的开端，表示开始说明需要的权限。
        //需要的权限分两部分，第一部分是拦截的路径，第二部分访问该路径需要的权限。
        //antMatchers表示拦截什么路径，permitAll任何权限都可以访问，直接放行所有。
        //anyRequest()任何的请求，authenticated认证后才能访问
        //.and().csrf().disable();固定写法，表示使csrf拦截失效。
        http
                .authorizeRequests()
                .antMatchers("/**").permitAll()
                .anyRequest().authenticated()
                .and().csrf().disable();
    }
}




 




 


 


 




 










            

            
posted @ 
2020-03-25 13:36 
MartinEDM 
阅读(1066) 
评论(0) 
 
收藏 
举报