使用JWT实现跨域身份验证

2021-03-08  本文已影响0人  惜鸟

一、传统用户的身份验证（使用session）

image.png
一般过程如下：
1、用户向服务器发送用户名和密码。
2、服务器验证通过后，将相关信息保存到当前session中。
3、服务器将session_id放到cookie中并返回给用户。
4、用户后续的每个请求都会将cookie中的session_id发送给服务器。
5、服务器收到session_id并对比session中的数据，确认用户身份。
使用session的方式验证身份存在的问题是:

二、解决方法

1、 session广播。
2、 将透明令牌存入cookie，将用户身份信息存入redis。
3、使用自包含令牌，通过客户端保存数据，而服务器不保存会话数据。JWT是这种解决方案的代表。

三、JWT令牌

JWT（JSON Web Tokens）是目前最流行的跨域认证解决方案, 是一个开放式标准(RFC 7519), 用于在各方之间以JSON对象安全传输信息。

详细信息可以查看官方文档：https://www.jsonwebtoken.io/

1、访问令牌的类型

image.png

2、JWT的组成

image.png
该对象为一个很长的字符串，字符之间通过"."分隔符分为三个子串。
每一个子串表示了一个功能块，总共有以下三个部分：JWT头、有效载荷和签名

JWT头

JWT头部分是一个描述JWT元数据的JSON对象，通常如下所示：

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

typ属性表示令牌的类型，JWT令牌统一写为JWT
alg属性表示签名使用的算法，默认为HMAC SHA256（写为HS256）
最后，使用Base64 URL算法将上述JSON对象转换为字符串保存。

有效载荷（payload/claims）

有效载荷部分，是JWT的主体内容部分，也是一个JSON对象，包含需要传递的数据。 JWT指定七个默认字段供选择。

iss：发行人
exp：到期时间
sub：主题
aud：用户
nbf：在此之前不可用
iat：发布时间
jti：JWT ID用于标识该JWT

在源码中有一个Claims接口定义了对应的默认字段如下：


Claims

除以上默认字段外，我们还可以自定义私有字段，如下例：

{
"sub": "1234567890",
"name": "Helen",
"admin": true
}

请注意，默认情况下JWT是未加密的，任何人都可以解读其内容，因此不要构建隐私信息字段，存放保密信息，以防止信息泄露。JSON对象也使用Base64 URL算法转换为字符串保存。

签名哈希(signature)

签名哈希部分是对上面两部分数据签名，通过指定的算法生成哈希，以确保数据不会被篡改。
首先，需要指定一个密码（secret）。该密码仅仅为保存在服务器中，并且不能向用户公开。然后，使用标头中指定的签名算法（默认情况下为HMAC SHA256）根据以下公式生成签名:

HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(claims), secret)

在计算出签名哈希后，JWT头，有效载荷和签名哈希的三个部分组合成一个字符串，每个部分用"."分隔，就构成整个JWT对象。

base64url算法

如前所述，JWT头和有效载荷序列化的算法都用到了Base64URL。该算法和常见Base64算法类似，稍有差别。
作为令牌的JWT可以放在URL中（例如api.example/?token=xxx）。 Base64中用的三个字符
是"+"，"/"和"="，由于在URL中有特殊含义，因此Base64URL中对他们做了替换："="去掉，"+"用"-"替换，"/"用"_"替换，这就是Base64URL算法。

JWT的验证流程

{
"sub": "1234567890",
"name": "Helen",
"admin": true
}

之后，当用户与服务器通信时，客户在请求中发回JSON对象。服务器仅依赖于这个JSON对象来标识用户。为了防止用户篡改数据，服务器将在生成对象时添加签名。服务器不保存任何会话数据，即服务器变为无状态，使其更容易扩展。

JWT的优缺点

三、java整合JWT

1、添加JWT的依赖

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

2、创建JWT工具类


import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.util.Date;


public class JWTUtil {

    public static final String APPSECRET = "123456";

    /**
     * 生成token
     * @param name
     * @return
     */
    public static String getToken(String name) {
        if (name != null) {
            String token = Jwts.builder()
                    // 设置主题
                    .setSubject("test")
                    // 设置发布时间
                    .setIssuedAt(new Date())
                    // 设置过期时间，这里设置为30分钟后过期
                    .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 30))
                    // 设置自定义数据
                    .claim("name", name)
                    // 设置加密算法
                    .signWith(SignatureAlgorithm.HS256, APPSECRET)
                    // 压缩成字符串形式
                    .compact();
            return token;
        }

        return null;
    }

    /**
     * 通过token获取有效载荷
     * @param token
     * @return
     */
    public static Claims checkJwt(String token) {
        return Jwts.parser()
                .setSigningKey(APPSECRET)
                // 这里需要注意使用的是 parseClaimsJws 其中还有类似的方法如：parseClaimsJwt
                // JWS是 signed JWT 的缩写，JWT加密签名后就是JWS
                .parseClaimsJws(token)
                .getBody();
    }

    public static void main(String[] args) {
        String token = JWTUtil.getToken("test");
        System.out.println(token);
        Claims claims = JWTUtil.checkJwt(token);
        String name = claims.get("name", String.class);
        System.out.println(name);
    }
}

查看DefaultJwtBuilder.java的compact方法的源码验证前面所描述的内容，源代码如下：


    @Override
    public String compact() {
        if (payload == null && Collections.isEmpty(claims)) {
            throw new IllegalStateException("Either 'payload' or 'claims' must be specified.");
        }

        if (payload != null && !Collections.isEmpty(claims)) {
            throw new IllegalStateException("Both 'payload' and 'claims' cannot both be specified. Choose either one.");
        }

        if (key != null && keyBytes != null) {
            throw new IllegalStateException("A key object and key bytes cannot both be specified. Choose either one.");
        }

        Header header = ensureHeader();

        Key key = this.key;
        if (key == null && !Objects.isEmpty(keyBytes)) {
            key = new SecretKeySpec(keyBytes, algorithm.getJcaName());
        }

        JwsHeader jwsHeader;

        if (header instanceof JwsHeader) {
            jwsHeader = (JwsHeader)header;
        } else {
            jwsHeader = new DefaultJwsHeader(header);
        }

        if (key != null) {
            jwsHeader.setAlgorithm(algorithm.getValue());
        } else {
            //no signature - plaintext JWT:
            jwsHeader.setAlgorithm(SignatureAlgorithm.NONE.getValue());
        }

        if (compressionCodec != null) {
            jwsHeader.setCompressionAlgorithm(compressionCodec.getAlgorithmName());
        }

        String base64UrlEncodedHeader = base64UrlEncode(jwsHeader, "Unable to serialize header to json.");

        String base64UrlEncodedBody;

        if (compressionCodec != null) {

            byte[] bytes;
            try {
                bytes = this.payload != null ? payload.getBytes(Strings.UTF_8) : toJson(claims);
            } catch (JsonProcessingException e) {
                throw new IllegalArgumentException("Unable to serialize claims object to json.");
            }

            base64UrlEncodedBody = TextCodec.BASE64URL.encode(compressionCodec.compress(bytes));

        } else {
            base64UrlEncodedBody = this.payload != null ?
                    TextCodec.BASE64URL.encode(this.payload) :
                    base64UrlEncode(claims, "Unable to serialize claims object to json.");
        }
        // 这里验证了我们上面说的 JWT 的组成内容 JwtParser.SEPARATOR_CHAR='.'
        String jwt = base64UrlEncodedHeader + JwtParser.SEPARATOR_CHAR + base64UrlEncodedBody;

        if (key != null) { //jwt must be signed:

            JwtSigner signer = createSigner(algorithm, key);

            String base64UrlSignature = signer.sign(jwt);

            jwt += JwtParser.SEPARATOR_CHAR + base64UrlSignature;
        } else {
            // no signature (plaintext), but must terminate w/ a period, see
            // https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-25#section-6.1
            jwt += JwtParser.SEPARATOR_CHAR;
        }

        return jwt;
    }
上一篇下一篇

猜你喜欢

热点阅读