首頁手記 JWT單點登錄原理教程：輕松入門詳解

JWT單點登錄原理教程：輕松入門詳解

標簽：

PHP 安全 API

JWT概述

JWT是什么

JWT（JSON Web Token）是一种开放标准（RFC 7519），用于在各方之间安全地传输信息。JWT的主要特点是紧凑性、自包含和无状态。它由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。JWT通常以JSON对象的形式表示，并通过URL安全编码（Base64URL编码）传输。

JWT的作用和优势

JWT主要用于身份验证和授权，其主要作用包括：

身份验证：通过JWT传递用户信息，验证用户身份。
授权：根据JWT中的信息，决定用户是否有权限访问某个资源。
信息传递：JWT可以传递用户信息、会话信息等，便于前后端的数据交换。

JWT的优势包括：

无状态：服务器无需保存会话状态，减轻了服务器的负载。
安全性：通过加密签名，确保数据的完整性和不可篡改性。
跨域支持：JWT可以轻松地通过HTTP头或Cookie进行传递，支持跨域访问。

JWT的基本结构

JWT由三个部分组成：

Header：包含类型（"typ"）和算法（"alg"）。例如：
```
{
"alg": "HS256",
"typ": "JWT"
}
```

Payload：包含声明（Claims）。例如：

{
"sub": "1234567890",
"name": "John Doe",
"iat": 1516239022
}

Signature：通过Header和Payload生成，采用指定的算法（如HS256）进行签名。例如：

{
"header": "base64UrlEncode(header)",
"payload": "base64UrlEncode(payload)",
"signature": HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)
}

单点登录（SSO）概述

单点登录的基本概念

单点登录（Single Sign On，SSO）是指用户只需登录一次，即可访问多个相关或独立的应用系统，而无需再次进行身份验证。SSO的核心目标是简化用户身份验证过程，提高用户体验，并减少安全风险。

单点登录的应用场景

单点登录广泛应用于企业级应用、Web应用、移动应用等场景。例如：

企业内部系统：企业内部的多个系统（如CRM、ERP、HR等）可以使用SSO实现统一登录。
Web应用：多个关联的网站（如社区、论坛、博客等）可以使用SSO实现用户的一次登录多处访问。
移动应用：多个移动应用之间可以使用SSO实现用户的一次登录多应用访问。

单点登录的实现方式

单点登录的实现方式主要有以下几种：

数据库共享：所有应用共享同一个用户数据库，统一管理用户身份信息。
认证服务器：设置一个中心化的认证服务器，负责用户的认证和会话管理。
令牌传递：使用令牌（如JWT）传递用户身份信息，实现多个应用之间的单点登录。

JWT与单点登录的关系

JWT如何支持单点登录

JWT通过传递用户身份信息支持单点登录。在用户首次登录时，服务器会生成一个JWT，并返回给客户端。客户端将JWT存储起来，并在后续请求中通过HTTP头或Cookie传递JWT，以验证用户身份。服务器接收到JWT后，会对其进行解码和验证，确保用户身份信息的有效性和完整性。

JWT单点登录的工作流程

JWT单点登录的工作流程主要包括以下几个步骤：

用户登录：用户提交登录请求，服务器验证用户身份并生成JWT。
JWT传递：将生成的JWT返回给客户端，并存储在客户端（如Cookie或本地存储）。
JWT验证：在后续请求中，客户端将JWT传递给服务器，服务器对其进行解码和验证。
刷新JWT：当JWT即将过期时，客户端可以请求服务器刷新JWT，以延长会话时间。

JWT单点登录的安全性

JWT单点登录的安全性主要体现在以下几个方面：

加密签名：JWT通过加密签名确保数据的完整性和不可篡改性。
JWT过期时间：设置合理的过期时间，防止JWT长期有效带来的安全风险。
密钥管理：妥善管理JWT签名所需的密钥，防止密钥泄露。
会话管理：在用户退出时，立即注销JWT，防止会话劫持。

实现JWT单点登录的步骤

准备工作与依赖库的安装

实现JWT单点登录需要准备相关工具和库。以下是一个简单的准备工作示例：

环境配置：确保开发环境中有Java开发工具和相应的IDE。
项目创建：使用Maven或Gradle创建一个新的Java项目。

依赖库安装：安装JWT相关的依赖库。例如，使用Maven安装jjwt库：

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

用户身份验证与生成JWT

实现用户身份验证与生成JWT的过程如下：

用户认证：验证用户提供的用户名和密码是否正确。
生成JWT：使用org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder对用户密码进行加密，然后生成JWT。

示例代码：

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

public class JwtUtils {
    private static final String SECRET = "secret";
    private static final long EXPIRATION = 1000 * 60 * 30; // 30分钟过期时间
    private static final BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();

    public static String generateToken(String username, String password) {
        boolean isValid = passwordEncoder.matches(password, passwordEncoder.encode(password));
        if (!isValid) {
            throw new IllegalArgumentException("Invalid credentials");
        }

        return Jwts.builder()
                .setSubject(username)
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION))
                .signWith(SignatureAlgorithm.HS256, SECRET.getBytes())
                .compact();
    }
}

JWT的存储与传递

JWT的存储与传递可以通过以下方式实现：

存储：将JWT存储在客户端的Cookie或本地存储中。
传递：在后续的请求中，通过HTTP头或Cookie传递JWT。

示例代码：

// 设置JWT到Cookie
response.addHeader("Set-Cookie", "token=" + token + "; Path=/; HttpOnly");

// 从Cookie中获取JWT
String token = request.getHeader("Cookie")
        .split(";")[0]
        .split("=")[1];

JWT的验证与刷新

JWT的验证与刷新过程如下：

验证JWT：解码JWT并验证其签名和过期时间。
刷新JWT：当JWT即将过期时，请求服务器刷新JWT。

示例代码：

public static Claims validateToken(String token) {
    try {
        return Jwts.parser()
                .setSigningKey(SECRET.getBytes())
                .parseClaimsJws(token)
                .getBody();
    } catch (Exception e) {
        return null;
    }
}

public static String refreshToken(String token) {
    Claims claims = validateToken(token);
    if (claims != null) {
        claims.setExpiration(new Date(System.currentTimeMillis() + EXPIRATION));
        return Jwts.builder()
                .setClaims(claims)
                .signWith(SignatureAlgorithm.HS256, SECRET.getBytes())
                .compact();
    }
    return null;
}

实际案例：使用Spring Boot实现JWT单点登录

创建Spring Boot项目

使用Spring Boot创建一个新的项目。在pom.xml中添加JWT相关的依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>
</dependencies>

配置JWT相关的依赖

在application.properties中配置JWT的过期时间等参数：

jwt.secret=secret
jwt.expiration=1000 * 60 * 30
jwt.header=Authorization
jwt.prefix=Bearer

编写JWT生成、验证的代码

编写JWT生成和验证的代码。示例代码如下：

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Date;

@RestController
public class AuthController {

    private static final String SECRET = "secret";
    private static final long EXPIRATION = 1000 * 60 * 30;
    private static final BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();

    @PostMapping("/login")
    public void login(@RequestBody LoginRequest request, HttpServletResponse response) {
        boolean isValid = passwordEncoder.matches(request.getPassword(), passwordEncoder.encode(request.getPassword()));
        if (!isValid) {
            throw new IllegalArgumentException("Invalid credentials");
        }

        String token = Jwts.builder()
                .setSubject(request.getUsername())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION))
                .signWith(SignatureAlgorithm.HS256, SECRET.getBytes())
                .compact();

        response.addHeader("Set-Cookie", "token=" + token + "; Path=/; HttpOnly");
    }

    @GetMapping("/refresh")
    public String refreshToken(HttpServletRequest request, HttpServletResponse response) {
        String token = request.getHeader("Cookie")
                .split(";")[0]
                .split("=")[1];

        Claims claims = Jwts.parser()
                .setSigningKey(SECRET.getBytes())
                .parseClaimsJws(token)
                .getBody();

        claims.setExpiration(new Date(System.currentTimeMillis() + EXPIRATION));
        String newToken = Jwts.builder()
                .setClaims(claims)
                .signWith(SignatureAlgorithm.HS256, SECRET.getBytes())
                .compact();

        response.addHeader("Set-Cookie", "token=" + newToken + "; Path=/; HttpOnly");
        return newToken;
    }

    @GetMapping("/protected")
    public String protectedResource(HttpServletRequest request) {
        String token = request.getHeader("Cookie")
                .split(";")[0]
                .split("=")[1];

        Claims claims = Jwts.parser()
                .setSigningKey(SECRET.getBytes())
                .parseClaimsJws(token)
                .getBody();

        return "Welcome " + claims.getSubject();
    }
}

测试JWT单点登录功能

编写测试用例，验证JWT单点登录功能的正确性。示例代码如下：

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.web.context.WebApplicationContext;

import static org.springframework.boot.test.context.SpringBootTest.WebEnvironment.RANDOM_PORT;

@SpringBootTest(webEnvironment = RANDOM_PORT)
public class AuthControllerTest {
    private MockMvc mockMvc;

    public AuthControllerTest(WebApplicationContext context) {
        this.mockMvc = MockMvcBuilders.webAppContextSetup(context).build();
    }

    public void testLogin() throws Exception {
        MvcResult result = mockMvc.perform(
                MockMvcRequestBuilders.post("/login")
                        .contentType("application/json")
                        .content("{\"username\":\"john\", \"password\":\"password\"}")
        ).andReturn();

        String response = result.getResponse().getContentAsString();
        assert response.startsWith("token=");
    }

    public void testRefreshToken() throws Exception {
        MvcResult loginResult = mockMvc.perform(
                MockMvcRequestBuilders.post("/login")
                        .contentType("application/json")
                        .content("{\"username\":\"john\", \"password\":\"password\"}")
        ).andReturn();

        String token = loginResult.getResponse().getContentAsString().split("=")[1];

        MvcResult refreshTokenResult = mockMvc.perform(
                MockMvcRequestBuilders.get("/refresh")
                        .header("Cookie", "token=" + token)
        ).andReturn();

        String newToken = refreshTokenResult.getResponse().getContentAsString().split("=")[1];
        assert newToken.length() > 0;
    }

    public void testProtectedResource() throws Exception {
        MvcResult loginResult = mockMvc.perform(
                MockMvcRequestBuilders.post("/login")
                        .contentType("application/json")
                        .content("{\"username\":\"john\", \"password\":\"password\"}")
        ).andReturn();

        String token = loginResult.getResponse().getContentAsString().split("=")[1];

        MvcResult protectedResourceResult = mockMvc.perform(
                MockMvcRequestBuilders.get("/protected")
                        .header("Cookie", "token=" + token)
        ).andReturn();

        String response = protectedResourceResult.getResponse().getContentAsString();
        assert response.startsWith("Welcome john");
    }
}

常见问题与解决方案

JWT过期处理

JWT过期后，通常需要刷新JWT以延长会话时间。可以通过以下方式处理JWT过期：

刷新JWT：在JWT即将过期时，请求服务器刷新JWT。
自动刷新：通过设置拦截器，自动处理JWT刷新。

示例代码：

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class JwtFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;

        String token = httpRequest.getHeader("Cookie")
                .split(";")[0]
                .split("=")[1];

        Claims claims = Jwts.parser()
                .setSigningKey(SECRET.getBytes())
                .parseClaimsJws(token)
                .getBody();

        if (claims.getExpiration().before(new Date())) {
            String newToken = refreshToken(token);
            httpResponse.addHeader("Set-Cookie", "token=" + newToken + "; Path=/; HttpOnly");
        }

        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {
    }
}

JWT的安全风险与防范

JWT面临的主要安全风险包括：

密钥泄露：如果JWT签名密钥泄露，攻击者可以伪造JWT。
Token泄漏：如果JWT被泄露，攻击者可以冒充用户身份。
篡改Payload：攻击者可以篡改JWT中的Payload数据。

防范措施包括：

密钥保护：妥善管理JWT签名所需的密钥。
Token防护：通过设置HttpOnly和Secure属性，保护Cookie中的JWT。
Payload验证：在服务器端验证JWT中的Payload数据。

JWT与Cookie的区别与选择

JWT与Cookie的主要区别如下：

存储位置：JWT通常存储在本地存储或HTTP头，而Cookie存储在服务器端。
数据量：JWT可以包含更多的数据，而Cookie的大小有限制。
安全性：JWT通过加密签名保证安全性，而Cookie可以通过HttpOnly和Secure属性保护。

选择使用JWT还是Cookie取决于具体的应用场景和需求。JWT适用于无状态和跨域访问的场景，而Cookie适用于本地存储和会话管理的场景。

总结，JWT单点登录是一种高效、安全的身份验证方式，利用JWT的无状态特性和紧凑性，可以方便地实现单点登录功能。通过合理的实现和配置，可以确保JWT单点登录的安全性和可靠性。

點擊查看更多內容

為 TA 點贊

若覺得本文不錯，就分享一下吧！

評論

評論

共同學習，寫下你的評論

評論加載中...

展開查看更多評論

作者其他優質文章

正在加載中

呼啦一陣風

手記
篇

粉絲

74

獲贊與收藏

323

關注作者，訂閱最新文章

閱讀免費教程

ThinkPHP 入門教程

28個小節 12718 127

Java 并發原理入門教程

26個小節 40058 581

HTTP 入門教程

28個小節 38621 666

推薦

評論

收藏

共同學習，寫下你的評論



感謝您的支持，我會繼續努力的～

掃碼打賞，你說多少就多少

贊賞金額會直接到老師賬戶

支付方式

打開微信掃一掃，即可進行掃碼打賞哦

今天注冊有機會得

100積分直接送

付費專欄免費學

大額優惠券免費領

立即參與放棄機會

點擊
抽獎

慕課手記新用戶專享福利

恭喜你，你的運氣太好了，居然抽中了 100個積分！

恭喜你，抽中了價值元的專欄！

太棒了，直接落到你賬戶里！

積分商城里的羅技鼠標、機械鍵盤、
Kindle 閱讀器、小米平衡車
Apple iPad （10.2英寸）、大額優惠券
在等著你去兌換了噢

作者：

免費贈送

兌換碼：1111222211 復制

優惠券可用于購買實戰課、體系課
無門檻使用

先去看看，有什么好東西馬上兌換我愛學習，選課去


亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

熱搜

最近搜索清空

JWT單點登錄原理教程：輕松入門詳解

JWT是什么

JWT的作用和优势

JWT的基本结构

单点登录的基本概念

单点登录的应用场景

单点登录的实现方式

JWT如何支持单点登录

JWT单点登录的工作流程

JWT单点登录的安全性

准备工作与依赖库的安装

用户身份验证与生成JWT

JWT的存储与传递

JWT的验证与刷新

创建Spring Boot项目

配置JWT相关的依赖

编写JWT生成、验证的代码

测试JWT单点登录功能

JWT过期处理

JWT的安全风险与防范

JWT与Cookie的区别与选择

閱讀免費教程