（一）名词介绍

ゞ浴缸里的玫瑰 2023-06-30 06:45 7阅读 0赞

一、Spring Security：通过继承

org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter

实现权限配置，登录验证成功后初始化org.springframework.security.core.userdetails.UserDetails，存储当前登录用户。默认（可缺省）登录接口：/login

二、JWT无状态登录：

1、介绍：全称json web token轻量级的授权和身份认证规范。  
JWT包含三部分  
Header: base64加密可解密加密，不要存放关键信息

声明类型:“tpy”:“JWT”,  
加密算法:“alg”:“RS256”  
PayLoad:存放有效数据，不写死，base64加密可解密加密,根据需要来写。  
举例：

用户名信息 “name”:“zhangsan”,  
权限信息 “admin”：“true”  
签发时间 “iat”:“1516239022”  
iss：发行人  
exp：到期时间  
sub：主题  
aud：用户  
nbf：在此之前不可用  
jti：JWT ID用于标识该JWT  
Signature：签名 RSA非对称加密，无密钥无法解密，只能验证。  
RSASHA256(baseUrlEncode(header)+"."+base64UrlEncode(payload),秘钥)  
先对原header及payload信息有效性进行加密。

2、与session相对比较：

（1）有状态登录session：tomcat中，把用户的登录信息保存在服务端的session中，再给用户一个cookie值。记录对应的session值，下次客户端带cookie来访问时，再识别对应的session找到用户的信息。缺点：服务器的负荷变大，保存大量的session数据。

（2）无状态登录jwt：服务器不保存用户的登录信息，由客户端请求携带自己的身份信息（带入token来获取身份认证）。服务器不再保存用户的登录信息，多次请求不用访问回到同一台服务，服务器可以弹性伸缩，减小服务端压力，缺点一旦JWT签发，在有效期内这个token将会一直有效，而session有自己的会话周期。

3、流程：

*  第一次请求访问时候，由服务器对用户进行身份验证
 *  验证通过，将身份信息加密进程token，返回给客户端，作为其访问其他服务器集群的身份凭证。
 *  每次请求携带token，服务器对其进行解密判断有效性。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70][]

4、安全问题：token必须安全可靠，采用JWT + RSA非对称加密，另外，JWT一旦签发，在有效期内将会一直有效，可以通过设置较短过期时间，或在业务接口再次做判断、再加入拦截等方法来减小安全风险。

5、（token）jwt插件：Auto0和jsonwebtoken都可以生成token，其中,auth0的maven依赖为：

jsonwebtoken的maven依赖为：

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

两个插件对比：

（1）Auto0工具类

import com.auth0.jwt.JWT;
    import com.auth0.jwt.JWTCreator;
    import com.auth0.jwt.algorithms.Algorithm;
    import com.auth0.jwt.exceptions.JWTVerificationException;
    import com.auth0.jwt.interfaces.DecodedJWT;
    import com.auth0.jwt.interfaces.JWTVerifier;
    import org.springframework.beans.factory.annotation.Value;
    
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @author: lizz
     * @date: 2020/1/20 09:58
     */
    public class Auth0Util {
        /**
         * 引入apollo的配置
         */
        private static String TOKEN_KEY = "54f12048-1f56-45c1-a3f1-2c546bc2bb42";
        /**
         * jwt有效时间
         */
        private static long TOKEN_TIMEOUT = 10* 60 * 1000;
    
        /**
         * jwt生成方
         */
        private final static String JWT_ISSUER = "lb-fw-gw";
    
        /**
         * 生成jwt
         *
         * @param header
         * @return
         */
        public static String create(Map<String, Object> header) {
            return create(header, new HashMap<>(0), JWT_ISSUER, TOKEN_TIMEOUT);
        }
    
        public static String create(Map<String, Object> header, Map<String, String> claims) {
            return create(header, claims, JWT_ISSUER, TOKEN_TIMEOUT);
        }
    
        public static String create(Map<String, Object> header, long timeout) {
            return create(header, new HashMap<>(0), JWT_ISSUER, timeout);
        }
    
        /**
         * 生成jwt
         *
         * @param header
         * @param issuer
         * @return
         */
        public static String create(Map<String, Object> header, Map<String, String> claims, String issuer, long timeout) {
            String token;
            try {
                Algorithm algorithm = Algorithm.HMAC256(TOKEN_KEY);
                Date date = new Date(System.currentTimeMillis() + timeout);
                JWTCreator.Builder builder = JWT.create()
                        .withHeader(header)
                        .withIssuer(issuer)
                        .withExpiresAt(date);
                for (String key : claims.keySet()) {
                    builder.withClaim(key, claims.get(key));
                }
                token = builder.sign(algorithm);
            } catch (JWTVerificationException exception) {
                System.out.println(exception.getMessage());
                return null;
            }
            return token;
        }
    
        /**
         * 验证jwt
         *
         * @param token
         * @return
         */
        public static DecodedJWT decode(String token) {
            DecodedJWT jwt;
            try {
                Algorithm algorithm = Algorithm.HMAC256(TOKEN_KEY);
                JWTVerifier verifier = JWT.require(algorithm)
    //                    .withIssuer(JWT_ISSUER)
    //                    .acceptLeeway(1)
    //                    .acceptExpiresAt(1)
    //                    .acceptIssuedAt(1)
    //                    .acceptNotBefore(1)
                        .build();
                jwt = verifier.verify(token);
            } catch (JWTVerificationException exception) {
                System.out.println(exception.getMessage());
                return null;
            }
            return jwt;
        }
    }

单测：

import org.junit.jupiter.api.Test;
    
    import java.util.HashMap;
    import java.util.Map;
    
    class Auth0UtilTest {
    
        /**
         * jwt创建测试结果
         * 次数 : 3批耗时ms
         * 1000 : 1502 1673 1513
         * 10000 : 2353 2319 2311
         * 100000 : 5681 5604 5452
         */
        @Test
        void create() {
            Map<String, Object> header = new HashMap<>(4);
            header.put("auth", "level1");
            Map<String, String> claims = new HashMap<>(4);
            claims.put("user", "xxxs");
            long btime = System.currentTimeMillis();
            int times = 100000;
            for (int i = 1; i <= times; i++) {
                Auth0Util.create(header);
            }
            System.out.println(System.currentTimeMillis() - btime);
        }
    
        /**
         * jwt校验测试结果
         * 次数 : 3批耗时ms
         * 1000 : 898 927 939
         * 10000 : 1973 1992 1882
         * 100000 : 4402 4562 4649
         */
        @Test
        void decode() {
            Map<String, Object> header = new HashMap<>(4);
            header.put("auth", "level1");
            Map<String, String> claims = new HashMap<>(4);
            claims.put("user", "xxxs");
            String token = Auth0Util.create(header); //创建一个新的token
            System.out.println("token：" + token);
            int times = 100000; //循环次数
            long btime = System.currentTimeMillis();
            for (int i = 1; i <= times; i++) {
                Auth0Util.decode(token);
            }
            System.out.println(System.currentTimeMillis() - btime);
        }
    }

（2）jsonwebtoken工具类

import io.jsonwebtoken.*;
    import io.jsonwebtoken.security.Keys;
    import org.springframework.beans.factory.annotation.Value;
    
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    import java.security.Key;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @description: jsonwebtoken工具类
     * @author: lizz
     * @date: 2020/2/25 4:18 下午
     */
    public class JsonWebTokenUtil {
        /**
         * jwt密钥 必须大于32个字符
         */
        private static String TOKEN_KEY = "54f12048-1f56-45c1-a3f1-2c546bc2bb42";
        /**
         * jwt有效时间
         */
        private static long TOKEN_TIMEOUT = 60 * 30 * 1000;
    
        /**
         * jwt生成方
         */
        private final static String JWT_ISSUER = "lb-fw-gw";
    
        /**
         * 生成jwt
         *
         * @param header
         * @return
         */
        public static String create(Map<String, Object> header) {
            return create(header, new HashMap<>(2), JWT_ISSUER, TOKEN_TIMEOUT);
        }
    
        public static String create(Map<String, Object> header, Map<String, Object> claims) {
            return create(header, claims, JWT_ISSUER, TOKEN_TIMEOUT);
        }
    
        public static String create(Map<String, Object> header, long timeout) {
            return create(header, new HashMap<>(2), JWT_ISSUER, timeout);
        }
    
        public static String create(Map<String, Object> header, Map<String, Object> claims, long timeout) {
            return create(header, claims, JWT_ISSUER, timeout);
        }
    
        /**
         * 生成jwt
         *
         * @param header
         * @return
         */
        public static String create(Map<String, Object> header, Map<String, Object> claims, String issuer, long timeout) {
            String token;
            try {
                Date date = new Date(System.currentTimeMillis() + timeout);
                SecretKey key = Keys.hmacShaKeyFor(TOKEN_KEY.getBytes());
                token = Jwts.builder()
                        .setHeader(header)
                        .setClaims(claims)
                        .setIssuer(issuer)
                        .setExpiration(date)
                        .signWith(key, SignatureAlgorithm.HS256)
                        .compact();
            } catch (JwtException exception) {
                System.out.println(exception.getMessage());
                return null;
            }
            return token;
        }
    
        /**
         * 验证jwt
         *
         * @param token
         * @return
         */
        public static Jws<Claims> decode(String token) {
            Jws<Claims> claimsJws;
            try {
                Key key = new SecretKeySpec(TOKEN_KEY.getBytes(), SignatureAlgorithm.HS256.getJcaName());
                claimsJws = Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token);
            } catch (JwtException exception) {
                System.out.println(exception.getMessage());
                return null;
            }
            return claimsJws;
        }
    }

单测：

import org.junit.jupiter.api.Test;
    
    import java.util.HashMap;
    import java.util.Map;
    class JsonWebTokenUtilTest {
    
        /**
         * jwt创建测试结果
         * 次数 : 3批耗时ms
         * 1000 : 2037 1850 2052
         * 10000 : 4874 4833 4908
         * 100000 : 18598 17841 17942
         */
        @Test
        void create() {
            HashMap<String, Object> header = new HashMap<>(4);
            header.put("auth", "level1");
            Map<String, Object> claims = new HashMap<>(4);
            claims.put("user", "xxxs");
            long btime = System.currentTimeMillis();
            int times = 100000;
            for (int i = 1; i <= times; i++) {
                JsonWebTokenUtil.create(header,claims);
            }
            System.out.println(System.currentTimeMillis() - btime);
        }
    
        /**
         * jwt校验测试结果
         * 次数 : 3批耗时ms
         * 1000 : 2128 1980 1933
         * 10000 : 9763 10073 9494
         * 100000 : 47531 48893 48845
         */
        @Test
        void decode() {
            HashMap<String, Object> header = new HashMap<>(4);
            header.put("auth", "level1");
            Map<String, Object> claims = new HashMap<>(4);
            claims.put("user", "xxxs");
            String token = JsonWebTokenUtil.create(header,claims); //创建一个新的token
            int times = 100000;
            long btime = System.currentTimeMillis();
            for (int i = 1; i <= times; i++) {
                JsonWebTokenUtil.decode(token);
            }
            System.out.println(System.currentTimeMillis() - btime);
        }
    }

（3）结论：

*  性能方面auth0更优。
 *  功能方面jsonwebtoken支持更高级的应用，如高级加密算法等。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190825140911882.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8=,size_16,color_FFFFFF,t_70