JWT单点登录 看这一篇就够了！

最新推荐文章于 2024-09-15 08:05:06 发布
最新推荐文章于 2024-09-15 08:05:06 发布
阅读量6.5k 收藏 39
点赞数 9
分类专栏： 单点登录 文章标签： jwt java 加密解密 后端 rsa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/especially_allen/article/details/106170394
版权

JWT单点登录

什么是JWT？

JWT，全称是Json Web Token， 是JSON风格轻量级的授权和身份认证规范，可实现无状态、分布式的Web应用授权；官网：https://jwt.io

GitHub上jwt的java客户端：https://github.com/jwtk/jjwt

两种登录状态

有状态登录

为了保证客户端cookie的安全性，服务端需要记录每次会话的客户端信息，从而识别客户端身份，根据用户身份进行请求的处理，典型的设计如tomcat中的session。

例如登录：用户登录后，我们把登录者的信息保存在服务端session中，并且给用户一个cookie值，记录对应的session。然后下次请求，用户携带cookie值来，我们就能识别到对应session，从而找到用户的信息。

缺点是什么？

  • 服务端保存大量数据，增加服务端压力
  • 服务端保存用户状态，无法进行水平扩展
  • 客户端请求依赖服务端，多次请求必须访问同一台服务器

即使使用redis保存用户的信息，也会损耗服务器资源。

无状态登录

微服务集群中的每个服务，对外提供的都是Rest风格的接口。而Rest风格的一个最重要的规范就是：服务的无状态性，即：

  • 服务端不保存任何客户端请求者信息
  • 客户端的每次请求必须具备自描述信息，通过这些信息识别客户端身份

带来的好处是什么呢？

  • 客户端请求不依赖服务端的信息，任何多次请求不需要必须访问到同一台服务
  • 服务端的集群和状态对客户端透明
  • 服务端可以任意的迁移和伸缩
  • 减小服务端存储压力

无状态登录流程

无状态登录的流程：

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

流程图：
在这里插入图片描述

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

token的安全性

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

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

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

jwt实现无状态登录

JWT，全称是Json Web Token， 是JSON风格轻量级的授权和身份认证规范，可实现无状态、分布式的Web应用授权；官网：https://jwt.io

GitHub上jwt的java客户端：https://github.com/jwtk/jjwt

数据格式

JWT包含三部分数据：

  • Header：头部，通常头部有两部分信息：

    • token类型：JWT
    • 加密方式：base64（HS256）

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

    • 用户身份信息（注意，这里因为采用base64编码，可解码，因此不要存放敏感信息）
    • 注册声明：如token的签发时间，过期时间，签发人等

    这部分也会采用base64编码，得到第二部分数据

  • Signature：签名，是整个数据的认证信息。根据前两步的数据，再加上指定的密钥（secret）（不要泄漏，最好周期性更换），通过base64编码生成。用于验证整个数据完整和可靠性
    在这里插入图片描述

JWT交互流程

流程图：
在这里插入图片描述
步骤翻译：

  • 1、用户登录
  • 2、服务的认证，通过后根据secret生成token
  • 3、将生成的token返回给浏览器
  • 4、用户每次请求携带token
  • 5、服务端利用公钥解读jwt签名，判断签名有效后，从Payload中获取用户信息
  • 6、处理请求，返回响应结果

因为JWT签发的token中已经包含了用户的身份信息，并且每次请求都会携带，这样服务的就无需保存用户信息，甚至无需去数据库查询，完全符合了Rest的无状态规范。

非对称加密

加密技术是对信息进行编码和解码的技术，编码是把原来可读信息（又称明文）译成代码形式（又称密文），其逆过程就是解码（解密），加密技术的要点是加密算法，加密算法可以分为三类：

  • 对称加密，如AES
    • 基本原理：将明文分成N个组，然后使用密钥对各个组进行加密，形成各自的密文，最后把所有的分组密文进行合并，形成最终的密文。
    • 优势：算法公开、计算量小、加密速度快、加密效率高
    • 缺陷：双方都使用同样密钥，安全性得不到保证
  • 非对称加密，如RSA
    • 基本原理：同时生成两把密钥：私钥和公钥，私钥隐秘保存，公钥可以下发给信任客户端
      • 私钥加密，持有公钥才可以解密
      • 公钥加密，持有私钥才可解密
    • 优点：安全，难以破解
    • 缺点：算法比较耗时
  • 不可逆加密，如MD5，SHA
    • 基本原理：加密过程中不需要使用密钥，输入明文后由系统直接经过加密算法处理成密文，这种加密后的数据是无法被解密的，无法根据密文推算出明文。

RSA算法历史：

1977年，三位数学家Rivest、Shamir 和 Adleman 设计了一种算法，可以实现非对称加密。这种算法用他们三个人的名字缩写：RSA

代码实现

本次示例采用SpringBoot工程搭建

核心依赖

<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
	<version>1.16.18</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.10.6</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.10.6</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.10.6</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>joda-time</groupId>
    <artifactId>joda-time</artifactId>
    <version>2.10.3</version>
</dependency>

核心工具类

如果需要使用JWT单点登录，RAS工具类和JWT工具类是必不可少的

JWT工具类

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.Map;

public class JwtUtils {
    /**
     * 私钥加密token
     *
     * @param map           载荷中的数据
     * @param expireMinutes 过期时间，单位秒
     * @return
     * @throws Exception
     */
    public static String generateToken(Map<String, Object> map, PrivateKey key, int expireMinutes) throws Exception {
        return Jwts.builder()
                .setClaims(map)
                .setExpiration(DateTime.now().plusMinutes(expireMinutes).toDate())
                .signWith(key, SignatureAlgorithm.RS256)
                .compact();
    }

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

    /**
     * 获取token中的用户信息
     *
     * @param token  用户请求中的令牌
     * @return 用户信息
     * @throws Exception
     */
    public static Map<String, Object> getInfoFromToken(String token, PublicKey key) throws Exception {
        Jws<Claims> claimsJws = parserToken(token, key);
        return claimsJws.getBody();
    }

}

RSA工具类

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

public class RsaUtils {
    /**
     * 从文件中读取公钥
     *
     * @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
     */
    public static PublicKey getPublicKey(byte[] bytes) throws Exception {
        X509EncodedKeySpec spec = new X509EncodedKeySpec(bytes);
        KeyFactory factory = KeyFactory.getInstance("RSA");
        return factory.generatePublic(spec);
    }

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

    /**
     * 根据密文，生存rsa公钥和私钥,并写入指定文件
     *
     * @param publicKeyFilename  公钥文件路径
     * @param privateKeyFilename 私钥文件路径
     * @param secret             生成密钥的密文
     * @throws IOException
     * @throws NoSuchAlgorithmException
     */
    public static void generateKey(String publicKeyFilename, String privateKeyFilename, String secret) throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        SecureRandom secureRandom = new SecureRandom(secret.getBytes());
        keyPairGenerator.initialize(2048, secureRandom);
        KeyPair keyPair = keyPairGenerator.genKeyPair();
        // 获取公钥并写出
        byte[] publicKeyBytes = keyPair.getPublic().getEncoded();
        writeFile(publicKeyFilename, publicKeyBytes);
        // 获取私钥并写出
        byte[] privateKeyBytes = keyPair.getPrivate().getEncoded();
        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);
    }
}

测试

公钥和私钥的区别，其实不用太过于纠结，我们可以理解为:

  • 私钥属于私密，用于生成token，返回加密数据给前端
  • 公钥属于公文，用于解析token，返回用户数据给前端
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.HashMap;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = JwtDemoApplication.class)
public class JwtDemoApplicationTests {

	// 公钥文件生成地址
    private static final String PUB_KEY_PATH = "D:\\IT notes\\jwt\\tool\\rsa.pub";
    // 私钥文件生成地址
    private static final String PRI_KEY_PATH = "D:\\IT notes\\jwt\\tool\\rsa.pri";
    
    private PublicKey publicKey;
    private PrivateKey privateKey;

    // 生成公钥和私钥
    @Test
    public void testRsa() throws Exception {
        RsaUtils.generateKey(PUB_KEY_PATH, PRI_KEY_PATH, "234");
    }

    // 先生成 再获取 生成之前把@Before注释掉！
    // 获取公钥和私钥
    @Before
    public void testGetRsa() throws Exception {
        this.publicKey = RsaUtils.getPublicKey(PUB_KEY_PATH);
        this.privateKey = RsaUtils.getPrivateKey(PRI_KEY_PATH);
    }

    // 生成token
    @Test
    public void testGenerateToken() throws Exception {
        Map<String, Object> map = new HashMap<>();
        map.put("id", "11");
        map.put("username", "liuyan");
        // 生成token
        String token = JwtUtils.generateToken(map, privateKey, 1);
        System.out.println("token = " + token);
    }

    // 解析token
    @Test
    public void testParseToken() throws Exception {
        String token = "eyJhbGciOiJSUzI1NiJ9.eyJpZCI6IjExIiwidXNlcm5hbWUiOiJsaXV5YW4iLCJleHAiOjE1ODc2MjYwODZ9.kO22BSWogDJPD6oG92dfFukothGMJej3FKLIfDJRVjGiF_O7kLPSmycmuyByy8wd7X_nOVDCPoMvvhoUzviDsgzIC0xiILoMobwyUDtbYdStCfiLVikqHmnf0Our5tuxwVaPOK2igoWW3zRRI7HG5RLh0p2pUAQe1C-is_8zczn2T5CQ-7vEwPS6U5FLn7_1y8rHNVsKlHqNBdSDxQn7jLOkHkKnRiShZ2_iBuXTzo6uZt2461IV8qk6Lmn35fyX7JHwHIVvuQyniFEsdYNW5t8P3Eo1UEbL3ZD5ZbhcIsK5gnvpXdsne6uK1jHQzClQi-hcGONuHXpS2IkueWEizg";
        // 解析token
        Map<String, Object> map = JwtUtils.getInfoFromToken(token, publicKey);
        System.out.println("id: " + map.get("id"));
        System.out.println("userName: " + map.get("username"));
    }
}
Allen_google
关注
专栏目录
看完就懂-SpringSecurity+JWT 实现单点登录
永远热泪盈眶 坚持输出
05-03 1102
单点登录（Single Sign On），简称为 SSO，是目前比较流行的企业业务整合的解决方案之一。SSO的定义是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统
单点登录JWT
qq614452400的博客
07-17 226
1 单点登录三种方法（第二三种常用） 2 第三种token可以使用jwt来实现生成字符串 怎么使用jwt 1，在pom中添加依赖 2 写工具类 public class JwtUtils { //EXPIRE表示token过期时间 APP_SECRET密钥为了做加密编码 public static final long EXPIRE = 1000 * 60 * 60 * 24; public static final String APP_SECRET = "ukc8BDbRigUDaY6pZFfWu
单点登录、JWT和OAuth2
weixin_45908458的博客
11-07 1394
单点登录在我们日常的业务开发中十分常见，单凡需要完成用户中心模块的开发都离不开单点登录，所以本文就来聊聊关于单点登录的那些事儿。首先，我们来看一看用户身份认证有哪些方式。 一、用户身份认证的方式 1. 单一服务器模式 ​ 单一服务器模式的实现原理十分简单，只需要将用户的相关登录数据(如用户名)存入session即可。随后服务器向用户返回session_id,session信息都会写入到用户的cookie,用户的每个后续请求都将通过在Cookie中取出session_id传给服务器，服务器收到sessio
基于SpringBoot+JWT实现单点登录解决方案
qq_53723451的博客
07-31 243
基于SpringBoot+JWT实现单点登录解决方案
SSOJWT：跨域单点登录实战指南
最新发布
gitblog_01002的博客
09-15 674
SSOJWT：跨域单点登录实战指南 ssojwt Cross domain SSO with JWT (no server session) 项目地址: https://gitcode.com/gh_mirrors/ss/ssoj...
如何使用JWT来实现单点登录功能
02-16 982
我们平时自己开发项目,分布式的结构时,访问量不大,但是又不想搭建redis服务器,这时我觉得jwt不错. 个人理解,jwt就是类似于一把锁和钥匙,客户来租房(登录),我们需要给他进来(第一次登录)登记消息,配把钥匙给他(使用jwt生成一个token,存放在用的cookie中),我们这边也需要配置一把我们需求的锁(jwt的生成token,解析token规则我们来写),接下来看下我最近运用...
JWT单点登录
weixin_47188125的博客
08-27 1246
通俗地说，JWT的本质就是一个字符串，它是将用户信息保存到一个Json字符串中，然后进行编码后得到一个JWT token，并且这个JWT token带有签名信息，接收后可以校验是否被篡改，所以可以用于在各方之间安全地将信息作为Json对象传输当然使用Session可以实现这个功能，但是使用Session的同时也会增加服务器的存储压力，而JWT是将存储的压力分布到各个客户端机器上，从而减轻服务器的压力。JWT由3个子字符串组成，分别为以及Signature。...
JWT实现单点登录
qq_41177523的博客
07-12 362
public class JwtUtil { public JwtUtil() { } public static String createJWT(String id, String subject, long ttl) { SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;...
jwt单点登录
m0_61682705的博客
11-20 1533
在我们日常开发中登录是每个系统都要做的，对于单点登录是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。开一下传统登录：单点登录：通俗讲：用户登录一次，就可已访问系统里的其他子系统。
JWT实现单点登录(SSO)
拾信
04-25 6783
相关技术名词： SSO、JWT、Redis、AOP、RSA、MD5 - salt
基于JWT实现SSO单点登录流程图解
08-18
主要介绍了基于JWT实现SSO单点登录流程图解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
cas jwt 单点登录
Rika_Sir_Zhong的博客
05-08 1879
单点登录是我比较喜欢的一个技术解决方案，一方面他能够提高产品使用的便利性，另一方面他分离了各个应用都需要的登录服务，对性能以及工作量都有好处。自从上次研究过JWT如何应用于会话管理，加之以前的项目中也一直在使用CAS这个比较流行的单点登录框架，所以就一直在琢磨如何能够把JWT跟单点登录结合起来一起使用，尽量能把两种技术的优势都集成到项目中来。本文介绍我从CAS思考得出的SSO的实现方案。 ** 前...
JWT实现单点登录完全跨域方案解析
"这篇文章主要介绍了如何使用JSON Web Token (JWT) 实现单点登录功能，特别是在完全跨域的场景下。JWT 是一个用于安全传输信息的开放标准，它通过数字签名确保信息的完整性和可验证性。JWT 适用于授权和信息交换，其...
JWT 单点登录
severl的博客
09-19 1687
JWT单点登录相关概念问题及基础操作介绍，附加面试题。
JWT——概念、认证流程、结构、使用JWT
Guizy
08-12 4477
一、什么是JWT JSON Web Token (JWT) is an open standard (RFC 7519) that defines a compact and self-contained way for securely transmitting information between parties as a JSON object. This information can be verified and trusted because it is digitally signed.
java jwt 单点登录
06-06
java jwt 单点登录是指使用Java程序实现单点登录(SSO)功能时，使用JWT（JSON Web Token）技术来保证用户身份的安全性和有效性。 JWT是一个轻量级的开放标准，用于在网络上传输数据。其包含三部分：Header、Payload和Signature。Header包含算法和token类型；Payload包含用户信息、权限以及过期时间等；Signature则是对Header和Payload的签名，以确保这个JWT是可信的。 在实现Java JWT单点登录时，首先需要通过一个认证服务器来颁发JWT token。用户登录成功后，服务器会生成一个JWT并返回给客户端。客户端收到token后，可以保存在本地进行后续操作。当用户访问其他系统时，需要携带这个JWT token，系统会通过请求头中的token信息，验证用户的身份。 通过JWT单点登录技术，用户只需要登录一次即可访问多个系统，不需要重复登录，大大提高了用户体验和安全性。同时，JWT token的加密和解密需要使用相同的密钥，这也可以更好地保障用户信息的安全性。 在Java中，可以使用第三方库如jjwt来简化JWT token的生成和验证过程。同时也可以使用Spring Security等框架来实现JWT单点登录功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值