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

最新推荐文章于 2024-05-30 07:31:24 发布
最新推荐文章于 2024-05-30 07:31:24 发布
阅读量5.8k 收藏 39
点赞数 8
分类专栏： 单点登录 文章标签： 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
关注
  • 8
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于JWT实现单点登录
Lyh_ok的博客
05-15 1万+
单点登录概述： 多系统共存下，用户在一处地方登录，得到其他所有系统的信任，无需再次登录。 自己的理解：在进行用户登录的时候，jwt生成一个token，用户带着这个token去其他页面进行验证。(token设置过期时间) 这里介绍一些jwt基本概念 JWT：1.认证流程 a.首先，前端通过web表单将自己的用户民和密码发送到后端的接口，这一过程一般是一个HTTP,POST请求。建议的方式是通过SSL 加密的方式传输(https协议)，从而避免敏感信息被嗅探。 b.后端核对用户名和密码成功后，将用户的id
jwt超时时间 angular expiredat_JWT实现单点登录的方法
weixin_39681644的博客
11-21 788
什么是JSON Web Token（JWT）？JSON Web Token（JWT）是一个开放标准（RFC 7519），它定义了一种紧凑且独立的方式，可以在各方之间作为JSON对象安全地传输信息。此信息可以通过数字签名进行验证和信任。JWT可以使用秘密（使用HMAC算法）或使用RSA或ECDSA的公钥/私钥对进行签名。虽然JWT可以加密以在各方之间提供保密，但只将专注于签名令牌。签名令牌可以验证其...
单点登录（JWT实现）
weixin_62773644的博客
05-27 394
如果无效的话请求打回，浏览器自动发起登录请求，此时网关服务器将请求路由到登陆服务上，登陆服务根据用户的信息生成一个JWT令牌，然后返回给网关，网关再返回给浏览器，此时将JWT放到浏览器的cookie中，之后每次请求都会带着cookie中的JWT。在单体项目中，我们登陆之后可以把验证用户信息的值放入session中，单个tomcat中的session是可以共享的。主要是要在每次发起服务请求时经过一个专门用来拦截请求的服务器，这个服务器我们可以当作是网关，然后使用这个服务器来进行校验token是否有效。
Java中JWT技术解析与实践：安全高效的身份认证
最新发布
Innocence_0的博客
05-30 758
什么是JWT（JSON Web Token）？JWT是一种用于身份验证和授权的开放标准（RFC7519），它是基于JSON格式的轻量级安全令牌。JWT由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。通常，JWT被用于在不同的系统之间传递安全性的声明信息，以便用户在跨域应用中进行身份验证。JWT有什么好处，能干啥？轻量级：JWT是基于JSON格式的，相比于传统的XML格式，它更加轻巧且易于解析。
springBoot整合spring security+JWT实现单点登录与权限管理前后端分离--筑基中期
qq_43788185的博客
09-05 1447
写在前面 在前一篇文章当中，我们介绍了springBoot整合spring security单体应用版，在这篇文章当中，我将介绍springBoot整合spring secury+JWT实现单点登录与权限管理。 本文涉及的权限管理模型是基于资源的动态权限管理。数据库设计的表有 user 、role、user_role、permission、role_permission。 单点登录当中，关于访问者信息的存储有多种解决方案。如将其以key-value的形式存储于redis数据库中，访问者令牌中存放key。校验
单点登录中的JSON WEB TOKEN的使用方法C#版
03-21
Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。本实例还原了整个的使用流程。建议使用vs2019,framework4.8版本。
JWT实现单点登录
Shu0Shuo的博客
05-15 2035
舔狗的自我修养：怕你（服务器）太累（装太多session数据），所以我来承担！！
jwt单点登录
m0_61682705的博客
11-20 1159
在我们日常开发中登录是每个系统都要做的，对于单点登录是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。开一下传统登录：单点登录：通俗讲：用户登录一次，就可已访问系统里的其他子系统。
浅谈JWT身份认证及其优缺点
江南烟雨却痴缠丶
03-27 5520
一、登录模式 在介绍JWT之前，我要先介绍一下常见的几种登录模式。 1、单一服务器模式(Session) 我们登录认证成功之后，将用户信息就存放在服务端(Session)，然后将其对应的session_id存储在客户端(Cookie)，从Cookie中取出session_id，服务端就可以根据这个session_id获取对应的Session，从而获取存储用户信息。 其优点是：Session自动续期，用户体验较好 其缺点是： ①没有分布式架构，无法支持横向扩展。即分布式架构的情况下，其他服务器是没有办法获取到
完全跨域的单点登录 完全跨域的单点登录
09-13
单点登录（Single Sign-On，简称SSO）是一种网络用户身份验证的机制，它允许用户在一次登录后，能够在多个相互关联的应用系统中自由切换，而无需再次输入认证信息。在Java开发环境中，实现完全跨域的单点登录是一项...
单点登录两篇不错的文章
03-19
单点登录（Single Sign-On，简称SSO）是一种网络身份验证机制，允许用户在一个系统上登录后，无需再次输入凭证即可访问多个相互关联的系统。SSO的主要目标是提高用户体验，减少用户记忆多个密码的负担，同时也能提高...
Spring Cloud 集成OAuth2实现身份认证和单点登录
07-20
单点登录（SSO）允许用户在一个系统登录后，无需再次登录就可以访问其他系统。在OAuth2框架下，通过共享同一访问令牌来实现SSO。当用户在授权服务器成功登录后，系统会为该用户颁发一个访问令牌。随后，用户在其他...
单点登录论文相关
10-17
提供的三篇文档——"基于SAML的单点登录系统的研究与实现"、"极通ESSO统一身份认证和单点登录系统技术白皮书V2.0"、"一种简单跨域单点登录系统的实现"将深入探讨这些方面，对于理解SSO有极大的帮助。
django使用JWT保存用户登录信息
01-21
该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务...
JWT单点登录
weixin_45427945的博客
06-09 1667
JWT单点登录
JWT 单点登录探析：原理、用途与安全实践
沉梦听雨的博客
12-22 1221
JWT （JSON Web Token） 是目前最流行的跨域认证解决方案，是。从 JWT 的全称可以看出，JWT 本身也是 Token，一种规范化之后的 JSON 结构的 Token。通过数字签名的方式，以 JSON 对象为载体，在不同的服务终端之间安全的传输信息。JWT，因此，我们的。这显然增加了系统的可用性和伸缩性，大大减轻了服务端的压力。(JWT 存储在【客户端】)
JWT——概念、认证流程、结构、使用JWT
Guizy
08-12 4238
一、什么是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.
使用jwt技术实现系统间的单点登录
热门推荐
05-26 2万+
单点登录（single sign on），简称sso。它的定义是多个应用系统间，只需要登录一次就可以访问所有相互信任的应用系统。下面介绍用jwt技术如何来实现单点登录。 一、JWT定义及其组成 JWT(JSON WEB TOKEN)是一个非常轻巧的规范，这个规范允许我们使用jwt在客户端和服务器之间传递安全可靠的信息。 JWT由3个部分组成，分别是头部、载荷、签名。 头部
OAuth2与JWT（单点登录）
qq_42296117的博客
07-29 1615
什么是单点登录？ 现在的应用几乎都是分布式，实现一方遍登录，分布的模块都不需要在进行登录授权 比如你在百度贴吧上登录了你的百度账号，在进入到贴吧的网页版，此时你是不需要重新登录就可以访问贴吧模块 那么单点登录的实现？ 1:使用session广播：将存入sesion的信息分发到各分布的模块中，进行复制。这种方式的话在如今局限比较大，在并发小的时候是可以用。因为这种方式限制了横向session的扩张，每个模块中的session都是所有模块的session信息 2:使用redis+cookie实现：使用re
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、付费专栏及课程。

余额充值