jwt《token》

 payload与claims只能存在一个
这部分是jwt源码：
依赖如下：官方文档的依赖

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.2</version>
</dependency>


<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.2</version>
</dependency>

<dependency>
    <groupId>io.jsonwebtoken </groupId >
    <artifactId>jjwt-jackson </artifactId >
    <version>0.11.2</version>
</dependency>

 

2020-11-1217:17:43
@Override
    public String compact() {

        if (this.serializer == null) {
            // try to find one based on the services available
            // TODO: This util class will throw a UnavailableImplementationException here to retain behavior of previous version, remove in v1.0
            // use the previous commented out line instead
            this.serializer = LegacyServices.loadFirst(Serializer.class);
        }

        if (payload == null && Collections.isEmpty(claims)) {//判断空
            payload = "";
        }

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

        Header header = ensureHeader();

        JwsHeader jwsHeader;
        if (header instanceof JwsHeader) {//判断header类型
            jwsHeader = (JwsHeader) header;
        } else {
            //noinspection unchecked
            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());
        }
           //header进行base64加密
        String base64UrlEncodedHeader = base64UrlEncode(jwsHeader, "Unable to serialize header to json.");
         //绿色部分表示payload转化base64加密成字节数组进行一次压缩
        byte[] bytes;
        try {
            bytes = this.payload != null ? payload.getBytes(Strings.UTF_8) : toJson(claims);
        } catch (SerializationException e) {
            throw new IllegalArgumentException("Unable to serialize claims object to json: " + e.getMessage(), e);
        }

        if (compressionCodec != null) {
            bytes = compressionCodec.compress(bytes);
        }
          //对payload压缩后的租界数组再来一次base64加密
        String base64UrlEncodedBody = base64UrlEncoder.encode(bytes);
     //签名拼接
        String jwt = base64UrlEncodedHeader + JwtParser.SEPARATOR_CHAR + base64UrlEncodedBody;



        // 加密的key再次判断为不为空       
        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;
    }

        个人模拟加密流程：

        //0  原始签名
        String header0 = "{\"alg\":\"HS256\"}";
        String claims0 = "{\"sub\":\"wangbiao\",\"aud\":\"wangbiao\"}";

        Encoder<byte[], String> base64UrlEncoder = Encoders.BASE64URL;
        String hed =base64UrlEncoder.encode(header0.getBytes("UTF-8"));

        Map map= (Map) JSON.parse(claims0);
        Serializer<Map<String,?>> serializer= LegacyServices.loadFirst(Serializer.class);
        byte[] clambyte0= serializer.serialize(map);


        /**
         * payload为空String方法转化字节数组，不然转化JSON序列化，默认payload为null 即上面的序列化
         * bytes = this.payload != null ? payload.getBytes(Strings.UTF_8) : toJson(claims);
         * byte [] claimbyte=claims0.getBytes("UTF-8");
         */


        /**
         *  默认jwt不需要压缩
         *        DeflateCompressionCodeWb deflateCompressionCodecss=new DeflateCompressionCodeWb();
         *        claims压缩字节
         *        byte[]  clambyte1 =deflateCompressionCodecss.doCompress(clambyte0);
         */

//        KeyPair keyPair = Keys.keyPairFor(SignatureAlgorithm.RS256);
        //签名key
        SecretKey key = Keys.secretKeyFor(SignatureAlgorithm.HS256);


        //字节在编码
        String cla= base64UrlEncoder.encode(clambyte0);
        String concatenated= hed+'.'+cla;

        //签名方式
        SignatureAlgorithm algorithm=SignatureAlgorithm.HS256;


        JwtSigner defaultJwtBuilder=new DefaultJwtSigner(algorithm,key,base64UrlEncoder);

        String base64UrlSignature = defaultJwtBuilder.sign(concatenated);
        String sss= concatenated+'.'+base64UrlSignature;
//        System.out.println(sss);
        //验签
        System.out.println(Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(sss));

 利用jwt封装的方法：

        //2设置token方式二 设置头
        Header header = new DefaultHeader();
        header.put("alg", "HS256");
//       //header设置方式1  设置map
        Map<String, Object> claims = new HashMap<>();
        claims.put("aud", "wangbiao");
        claims.put("sub", "wangbiao");
        String jwss = Jwts.builder()
                .setHeader((Map<String, Object>) header)
                .setClaims(claims)
                .signWith(key)
                .compact();
//        System.out.println(jwss);
        //验签
        System.out.println(Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(jwss));

 个人jwt生成结果：

eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ3YW5nYmlhbyIsImF1ZCI6IndhbmdiaWFvIn0.Lxso52KaEnj_a7mYAoH0eoPisIpCo_2sBihmf7sHxGw
jwt封装生成结果：

eyJhbGciOiJIUzI1NiJ9.eyJhdWQiOiJ3YW5nYmlhbyIsInN1YiI6IndhbmdiaWFvIn0.weI8QvS16782iZR6Hb3k3kYExmpSyax0a-KRzfG-vFc
可以看出最后签名不一致

       个人jwt验签解析：

header={alg=HS256},body={sub=wangbiao, aud=wangbiao},signature=Lxso52KaEnj_a7mYAoH0eoPisIpCo_2sBihmf7sHxGw

      jwt封装眼前解析：

header={alg=HS256},body={aud=wangbiao, sub=wangbiao},signature=weI8QvS16782iZR6Hb3k3kYExmpSyax0a-KRzfG-vFc

思考：通过追踪源码：发现默认情况下payload没有进行压缩

即没有进行如下操作：

if (compressionCodec != null) {
    bytes = compressionCodec.compress(bytes);
}

 

               payload为bull进行字符String转化为字节数组，不然转化为转化为tojSON（claims）序列化
bytes = this.payload != null ? payload.getBytes(Strings.UTF_8) : toJson(claims);
           
             header正常进行base64加密


猜想：我此处使用main方法测试，同一个线程下jwt签名具有不可重复，或者jwt默认就是签名不可重复

header={alg=HS256},body={aud=wangbiao, sub=wangbiao},signature=weI8QvS16782iZR6Hb3k3kYExmpSyax0a-KRzfG-vFc

官方文档有如下说明：意思就是如果在一个系统中使用不同的key需要自己重写，密匙解析器，好处就是方便不同的业务使用不同的加密方法，利用适配器的思想解决不同类型的key从而进行验签

：看源码太累，有哪位大神按照如下思路出个方案，共同进步

签名密钥分解器
如果您的应用程序期望使用不同的键签名的JWSs，您就不会调用setSigningKey方法。相反，您需要实现SigningKeyResolver接口，并通过setSigningKeyResolver方法在JwtParserBuilder上指定一个实例。
例如:
SigningKeyResolver signingKeyResolver = getMySigningKeyResolver();

Jwts.parserBuilder ()

   .setSigningKeyResolver (signingKeyResolver) / / <—

   .build ()
   .parseClaimsJws (jwsString);
通过扩展SigningKeyResolverAdapter并实现resolveSigningKey(JwsHeader, Claims)方法，可以简化一些事情。例如:
public class MySigningKeyResolver extends SigningKeyResolverAdapter {
    
    @Override
    public Key resolveSigningKey(JwsHeader jwsHeader, Claims claims) {
        // implement me
    }
}
JwtParser将在解析JWS JSON之后，但在验证JWS签名之前调用resolveSigningKey方法。这允许您检查JwsHeader并声明任何可以帮助您查找用于验证特定jws的键的信息。这对于具有更复杂安全模型的应用程序非常强大，这些应用程序可能在不同的时间使用不同的密钥，或者针对不同的用户或客户。
您可能会检查哪些数据?
JWT规范支持的方法是在创建JWS时在JWS头部设置一个kid (Key ID)字段，例如:

getSigningKey();

getKeyId(signingKey);//任何将密钥与ID关联的机制都可以

jws .builder()

   .setHeaderParam (JwsHeader。KEY_ID, keyId) // 1

   .signWith (signingKey) / / 2

   .compact ();
然后在解析期间，SigningKeyResolver可以检查JwsHeader以获取kid，然后使用该值从某个地方(比如数据库)查找键。例如:
public class MySigningKeyResolver extends SigningKeyResolverAdapter {
    
    @Override
    public Key resolveSigningKey(JwsHeader jwsHeader, Claims claims) {
        
        //inspect the header or claims, lookup and return the signing key
        
        String keyId = jwsHeader.getKeyId(); //或任何其他字段，你需要检查        
        Key key = lookupVerificationKey(keyId); //实现我
        
        return key;
    }
}
注意，检查jwsHeader.getKeyId()只是查找键的最常见方法—您可以检查任意数量的头字段或声明，以确定如何查找验证键。这完全取决于JWS是如何创建的。
最后请记住，对于HMAC算法，返回的验证密钥应该是一个秘钥，而对于非对称算法，返回的密钥应该是一个公钥(而不是一个私钥)。