无状态单点登录方案--jwt+rsa

无状态单点登录方案–jwt+rsa思路：
jwt（token格式）+RSA（非对称对token进行加密）+rsa（生成公、私钥；私钥加密，公钥解密）

分布式认证流程分为两种：
有状态登录：服务器需要存储token
无状态登录：服务器不用存储token

#无状态登录的流程：

• 当客户端第一次请求服务时，服务端对用户进行信息认证（登录）
• 认证通过，将用户信息进行加密形成token，返回给客户端，作为登录凭证
• 以后每次请求，客户端都携带认证的token
• 服务的对token进行解密，判断是否有效。

流程图：

整个登录过程中，最关键的点是什么？

token的安全性

token是识别客户端身份的唯一标示，如果加密不够严密，被人伪造那就完蛋了。

采用何种方式加密才是安全可靠的呢？

我们将采用JWT + RSA非对称加密

JWT

JWT包含三部分数据：
###1.Header：头部，
通常头部有两部分信息：

• 声明类型，这里是JWT
• 签名算法，自定义

我们会对头部进行base64编码，得到第一部分数据

如图所示：头部是不具备安全性的。

###2.Payload：载荷，
就是有效数据，一般包含下面信息：

• 用户身份信息（注意，这里因为采用base64加密，可解密，因此不要存放敏感信息）
• tokenID：当前这个JWT的唯一标示
• 注册声明：如token的签发时间，过期时间，签发人等

这部分也会采用base64加密，得到第二部分数据

如图所示：载荷也不具备安全性。

###3.Signature：签名，
是整个数据的认证信息。一般根据前两步的数据，再加上服务的的密钥（secret）（不要泄漏，最好周期性更换），通过加密算法生成。用于验证整个数据完整和可靠性
如果所示：签名中决定整个token是否安全的关键在盐。

生成的数据格式

JWT登录授权和鉴权流程

• 授权流程：
  • 1、用户请求登录，携带用户名密码到授权中心
  • 2、授权中心携带用户名密码，到用户中心查询用户
  • 3、查询如果正确，生成JWT凭证
  • 4、返回JWT给用户
• 鉴权流程：
  • 1、用户请求某微服务功能，携带JWT
  • 2、微服务将jwt交给授权中心校验
  • 3、授权中心返回校验结果到微服务
  • 4、微服务判断校验结果，成功或失败
  • 5、失败则直接返回401
  • 6、成功则处理业务并返回

可以发现，用户访问我们的网站，一次授权后，以后访问微服务都需要鉴权，那么每次鉴权都需要访问授权中心，一个用户请求，被分解为2次请求才能完成，效率比较低。
微服务并没有鉴定JWT的能力，因为鉴定需要通过密钥来完成。我们不能把密钥交给其它微服务，存在安全风险。-用这就要用到RSA非对称加密技术了

使用RSA（非对称）加密技术

有了非对称加密，我们就可以改变签名和验签的方式了：

• 生成RSA密钥对，私钥存放在授权中心，公钥下发给微服务
• 在授权中心利用私钥对JWT签名
• 在微服务利用公钥验证签名有效性

因为非对称加密的特性，不用担心公钥泄漏问题，因为公钥是无法伪造签名的，但要确保私钥的安全和隐秘。

非对称加密后的授权和鉴权流程：

用户只需要与微服务交互，不用访问授权中心，效率大大提高！

接下来让我们撸起袖子，开始写代码吧！

代码

##1.RSA工具
RSA工具类负责对RSA密钥的创建、读取功能：

package com.leyou.common.auth.utils;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

/**
 * @author 黑马程序员
 */
public class RsaUtils {

    private static final int DEFAULT_KEY_SIZE = 2048;
    /**
     * 从文件中读取公钥
     *
     * @param filename 公钥保存路径，相对于classpath
     * @return 公钥对象
     * @throws Exception
     */
    public static PublicKey getPublicKey(String filename) throws Exception {
        byte[] bytes = readFile(filename);
        return getPublicKey(bytes);
    }

    /**
     * 从文件中读取密钥
     *
     * @param filename 私钥保存路径，相对于classpath
     * @return 私钥对象
     * @throws Exception
     */
    public static PrivateKey getPrivateKey(String filename) throws Exception {
        byte[] bytes = readFile(filename);
        return getPrivateKey(bytes);
    }

    /**
     * 获取公钥
     *
     * @param bytes 公钥的字节形式
     * @return
     * @throws Exception
     */
    private static PublicKey getPublicKey(byte[] bytes) throws Exception {
        bytes = Base64.getDecoder().decode(bytes);
        X509EncodedKeySpec spec = new X509EncodedKeySpec(bytes);
        KeyFactory factory = KeyFactory.getInstance("RSA");
        return factory.generatePublic(spec);
    }

    /**
     * 获取密钥
     *
     * @param bytes 私钥的字节形式
     * @return
     * @throws Exception
     */
    private static PrivateKey getPrivateKey(byte[] bytes) throws NoSuchAlgorithmException, InvalidKeySpecException {
        bytes = Base64.getDecoder().decode(bytes);
        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(bytes);
        KeyFactory factory = KeyFactory.getInstance("RSA");
        return factory.generatePrivate(spec);
    }

    /**
     * 根据密文，生存rsa公钥和私钥,并写入指定文件
     *
     * @param publicKeyFilename  公钥文件路径
     * @param privateKeyFilename 私钥文件路径
     * @param secret             生成密钥的密文
     */
    public static void generateKey(String publicKeyFilename, String privateKeyFilename, String secret, int keySize) throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        SecureRandom secureRandom = new SecureRandom(secret.getBytes());
        keyPairGenerator.initialize(Math.max(keySize, DEFAULT_KEY_SIZE), secureRandom);
        KeyPair keyPair = keyPairGenerator.genKeyPair();
        // 获取公钥并写出
        byte[] publicKeyBytes = keyPair.getPublic().getEncoded();
        publicKeyBytes = Base64.getEncoder().encode(publicKeyBytes);
        writeFile(publicKeyFilename, publicKeyBytes);
        // 获取私钥并写出
        byte[] privateKeyBytes = keyPair.getPrivate().getEncoded();
        privateKeyBytes = Base64.getEncoder().encode(privateKeyBytes);
        writeFile(privateKeyFilename, privateKeyBytes);
    }

    private static byte[] readFile(String fileName) throws Exception {
        return Files.readAllBytes(new File(fileName).toPath());
    }

    private static void writeFile(String destPath, byte[] bytes) throws IOException {
        File dest = new File(destPath);
        if (!dest.exists()) {
            dest.createNewFile();
        }
        Files.write(dest.toPath(), bytes);
    }
}

##2.使用RSA生产公钥私钥

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

package com.leyou.common.auth.utils;

import org.junit.Test;

import java.security.PrivateKey;
import java.security.PublicKey;

import static org.junit.Assert.*;

public class RsaUtilsTest {

    private String pubPath = "D:\\ly_guangzhou126\\software\\rsa_key\\jwt_key.pub";

    private String priPath = "D:\\ly_guangzhou126\\software\\rsa_key\\jwt_key";

    @Test
    public void generateKey() throws Exception {
        //参数一：给公钥指定路径和名称，参数二：给私钥指定路径和名称，参数三：盐，参数四：密钥大小
        RsaUtils.generateKey(pubPath, priPath, "heima", 2048);
    }

    @Test
    public void getKey() throws Exception {
        PublicKey publicKey = RsaUtils.getPublicKey(pubPath);
        System.out.println(publicKey);
        PrivateKey privateKey = RsaUtils.getPrivateKey(priPath);
        System.out.println(privateKey);
    }
}

我们运行generateKey()，然后到指定的目录中查看：

3.JWT工具类

###3.1 pom

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.10.5</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.10.5</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.10.5</version>
    <scope>runtime</scope>
</dependency>

<!-- 后面的jwt工具类能用上-->
<dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.10.2</version>
        </dependency>

###3.2载荷对象
JWT中，会保存载荷数据，我们计划存储3部分：

• id：jwt的id
• 用户信息：用户数据，不确定，可以是任意类型
• 过期时间：Date

为了方便后期获取，我们定义一个类来封装：

package com.leyou.common.auth.pojo;

import lombok.Data;

import java.util.Date;

/**
 * @author 黑马程序员
 */
@Data
public class Payload<T> {
    private String id;
    private T userInfo;
    private Date expiration;
}

###3.3JWT工具

package com.leyou.common.auth.utils;

import com.leyou.common.auth.pojo.Payload;
import com.leyou.common.utils.JsonUtils;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jws;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.joda.time.DateTime;

import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;
import java.util.UUID;


public class JwtUtils {

    private static final String JWT_PAYLOAD_USER_KEY = "user";

    /**
     * 私钥加密token
     *
     * @param userInfo   载荷中的数据
     * @param privateKey 私钥
     * @param expire     过期时间，单位分钟
     * @return JWT
     */
    public static String generateTokenExpireInMinutes(Object userInfo, PrivateKey privateKey, int expire) {
        return Jwts.builder()
                .claim(JWT_PAYLOAD_USER_KEY, JsonUtils.toString(userInfo))
                .setId(createJTI())
                .setExpiration(DateTime.now().plusMinutes(expire).toDate())
                .signWith(privateKey, SignatureAlgorithm.RS256)
                .compact();
    }

    /**
     * 私钥加密token
     *
     * @param userInfo   载荷中的数据
     * @param privateKey 私钥
     * @param expire     过期时间，单位秒
     * @return JWT
     */
    public static String generateTokenExpireInSeconds(Object userInfo, PrivateKey privateKey, int expire) {
        return Jwts.builder()
                .claim(JWT_PAYLOAD_USER_KEY, JsonUtils.toString(userInfo))
                .setId(createJTI())
                .setExpiration(DateTime.now().plusSeconds(expire).toDate())
                .signWith(privateKey, SignatureAlgorithm.RS256)
                .compact();
    }

    /**
     * 公钥解析token
     *
     * @param token     用户请求中的token
     * @param publicKey 公钥
     * @return Jws<Claims>
     */
    private static Jws<Claims> parserToken(String token, PublicKey publicKey) {
        return Jwts.parser().setSigningKey(publicKey).parseClaimsJws(token);
    }

    private static String createJTI() {
        return new String(Base64.getEncoder().encode(UUID.randomUUID().toString().getBytes()));
    }

    /**
     * 获取token中的用户信息
     *
     * @param token     用户请求中的令牌
     * @param publicKey 公钥
     * @return 用户信息
     */
    public static <T> Payload<T> getInfoFromToken(String token, PublicKey publicKey, Class<T> userType) {
        Jws<Claims> claimsJws = parserToken(token, publicKey);
        Claims body = claimsJws.getBody();
        Payload<T> claims = new Payload<>();
        claims.setId(body.getId());
        claims.setUserInfo(JsonUtils.toBean(body.get(JWT_PAYLOAD_USER_KEY).toString(), userType));
        claims.setExpiration(body.getExpiration());
        return claims;
    }

    /**
     * 获取token中的载荷信息
     *
     * @param token     用户请求中的令牌
     * @param publicKey 公钥
     * @return 用户信息
     */
    public static <T> Payload<T> getInfoFromToken(String token, PublicKey publicKey) {
        Jws<Claims> claimsJws = parserToken(token, publicKey);
        Claims body = claimsJws.getBody();
        Payload<T> claims = new Payload<>();
        claims.setId(body.getId());
        claims.setExpiration(body.getExpiration());
        return claims;
    }
}

###3.4封装载荷类：UserInfo

这里我们假设用户信息包含3部分：

• id：用户id
• username：用户名
• role：角色（权限中会使用）

载荷:UserInfo

package com.leyou.common.auth.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserInfo {

    private Long id;

    private String username;
    
    private String role;
}

###3.5测试
生成token

//生成jwt的token
@Test
public void generateToken() throws Exception {
    PrivateKey privateKey = RsaUtils.getPrivateKey(privateKeyFilename);
    UserInfo userInfo = new UserInfo(1L, "Johnny", "Guest");
    String token = JwtUtils.generateTokenExpireInMinutes(userInfo, privateKey, 5);
    System.out.println("token = "+token);
}

解析token

//解析token
@Test
public void parseToken() throws Exception {
    String token = "eyJhbGciOiJSUzI1NiJ9.eyJ1c2VyIjoie1wiaWRcIjoxLFwidXNlcm5hbWVcIjpcIkpvaG5ueVwiLFwicm9sZVwiOlwiR3Vlc3RcIn0iLCJqdGkiOiJNVE5tT1dNNFlUVXRaRGN5WXkwME5ETmtMV0l5TURBdE5qa3hNR1JpWW1JM1l6TmwiLCJleHAiOjE1Nzc0MTMyNTN9.EP8v60_cwaJkNy4DerfUWfjKs-uzXC9qx5QB3IFiVxjvamg-8fbeBVUzdQ4z54csmPIzL4--1Jup3-oRbZudOThCoenAZXH4fze5vFCShUZJShAPxW57359_2PDQbaJbvNdRobOk1bjExVUTPJr0ptoejQdmdzt8ZIMJGpGPHlnyUqYbvBV_4Zag9G6vgzbx1sWxUk9j1V-GSlK4Mio64VFEr0eRxxBde_TkT8wdqn7UT_m0iYmkKtPyouRyxXdYa3IoL8Rmj0Um8IXQLMrvq74FwAHEUcBWZLPdltWn62VpQaSPQXYk-TpbpGSuso_SAMw2a3jME-4qiD2gpBrWAg";
    PublicKey publicKey = RsaUtils.getPublicKey(publicKeyFilename);
    Payload<UserInfo> infoFromToken = JwtUtils.getInfoFromToken(token, publicKey, UserInfo.class);
    UserInfo userInfo = infoFromToken.getUserInfo();
    System.out.println(userInfo);
    System.out.println(infoFromToken.getId());
    System.out.println(infoFromToken.getExpiration());
}

授权中心如何搭建呢，看这里：