JWT单点登录学习：入门指南与实战教程

JWT单点登录学习涉及JWT的基础概念、工作原理及其在单点登录中的应用。本文详细介绍了JWT的生成、验证和刷新过程，并提供了在不同框架中实现JWT单点登录的示例代码。通过这些内容，读者可以深入了解JWT技术及其在构建安全的单点登录系统中的应用。

JWT（JSON Web Token）是一种开放标准（RFC 7519），用于在双方之间安全地传输信息。JWT的设计初衷是为了提供一种安全的方式，用于在不同系统之间传递认证信息。这种令牌是自包含的，不需要服务器端保留任何状态信息，使得它非常适合用于分布式系统和微服务架构。

什么是JWT

JWT是一种紧凑、自包含的令牌，用于在网络上传递信息。它由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。

头部（Header）

头部通常包含两部分信息：令牌的类型（typ）和所使用的签名算法（alg）。例如，HS256表示使用HMAC-SHA-256算法进行签名。

{
  "typ": "JWT",
  "alg": "HS256"
}

载荷（Payload）

载荷包含声明（Claims），这些声明是对主体的声明，可以是公开的声明（如：iss、exp等）或私有声明。标准中定义了许多载荷字段，但也可以自定义用途的字段。

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

签名（Signature）

签名部分基于头部和载荷生成，用于验证消息的完整性。生成签名的步骤如下：

1. 将头部和载荷使用base64Url编码。
2. 拼接头部、.和载荷。
3. 使用密钥对拼接的字符串进行签名。

例如，如果使用HMAC SHA-256算法，签名的计算方式如下：

import hmac
import hashlib
import base64
import time

# 假设密钥为 'secret'
secret = 'secret'

# 头部和载荷
header = base64.urlsafe_b64encode(b'{"typ":"JWT","alg":"HS256"}').decode("utf-8")
payload = base64.urlsafe_b64encode(b'{"sub":"1234567890","name":"John Doe","iat":1516239022}').decode("utf-8")

# 拼接头部和载荷
message = header + '.' + payload

# 生成签名
signature = hmac.new(secret.encode(), message.encode(), hashlib.sha256).digest()
signature = base64.urlsafe_b64encode(signature).decode("utf-8")

# 最终的JWT
jwt_token = message + '.' + signature

JWT的工作原理

1. 认证请求：用户向服务器发送请求，请求认证。
2. 认证验证：服务器验证用户的凭证（如密码）。
3. 令牌生成：验证成功后，服务器生成一个JWT，并将其发送回客户端。
4. 令牌存储：客户端存储该JWT，通常存储在HTTP-only的Cookie中或LocalStorage中。
5. 令牌验证：客户端在后续的请求中携带JWT。
6. 服务器验证：服务器验证令牌的有效性，通常是通过签名和有效期来验证。
7. 访问资源：如果令牌有效，服务器将响应请求，允许用户访问资源。

JWT的优势与应用场景

优势：

1. 无状态性：服务器不需要存储任何状态信息，可以降低服务器的负载。
2. 安全性：使用加密签名确保令牌的完整性，防止篡改。
3. 扩展性：可以很容易地扩展令牌中包含的信息。

应用场景：

• 身份验证：在Web应用中用于用户登录。
• 授权：控制用户对资源的访问权限。
• 跨域共享：使得不同域之间的系统能够共享用户身份信息。
• API认证：保护RESTful API的安全。
• 单点登录：允许用户使用一组凭证登录一个系统，然后可以访问其他多个系统，无需再次进行身份验证。
• 会话管理系统：用于替代传统会话管理，实现更安全的认证方式。

单点登录的定义

单点登录（Single Sign-On，SSO）是一种身份验证方法，允许用户使用一组凭证（如用户名和密码）登录一个系统，然后可以访问其他多个系统，而无需再次进行身份验证。SSO系统可以显著提高用户体验，减少重复登录的过程。

单点登录的实现方式

SSO的实现方式有很多种，常见的包括：

1. Cookie-based SSO：使用共享的Cookie或Session存储用户的身份信息。
2. Token-based SSO：使用令牌（如JWT）进行身份验证，令牌可以在多个系统之间传递。
3. OAuth2/SSO：使用OAuth2协议实现单点登录。
4. LDAP：通过LDAP服务器进行身份验证。

JWT如何支持单点登录

JWT非常适合用于构建SSO系统，因为它具有无状态性和安全性。以下是如何利用JWT实现SSO的基本步骤：

1. 认证中心：用户登录时，认证中心验证用户凭证，并生成JWT。
2. 令牌传递：认证中心将生成的JWT传递给用户。
3. 资源服务器：用户尝试访问其他系统时，携带JWT进行身份验证。
4. 令牌验证：资源服务器验证JWT的有效性，验证通过后允许访问。

创建JWT令牌

生成JWT令牌需要包含以下步骤：

1. 安装JWT库：对于不同的编程语言，你可以使用相应的JWT库来生成和验证令牌。例如，在Node.js中，你可以使用jsonwebtoken库。

npm install jsonwebtoken

1. 生成令牌：使用库提供的方法生成令牌。

const jwt = require('jsonwebtoken');
const secret = 'my_secret_key';

const token = jwt.sign({
    sub: '1234567890',
    name: 'John Doe',
    iat: Math.floor(Date.now() / 1000)
}, secret, {
    algorithm: 'HS256'
});

console.log(token);

令牌的验证过程

验证JWT令牌需要以下步骤：

1. 提取令牌：从请求头或Cookie中提取JWT令牌。
2. 解码与验证：使用相同的密钥和算法来验证令牌的有效性。

const decoded = jwt.verify(token, secret, {
    algorithms: ['HS256']
});

console.log(decoded);

令牌的存储与刷新

令牌的存储和刷新是保证用户体验和安全性的关键步骤：

• 存储：将令牌存储在客户端，通常使用HTTP-only Cookie或LocalStorage。
• 刷新：设置合理的过期时间，当令牌过期时，客户端通过刷新令牌来获取新的令牌。

const refreshSecret = 'my_refresh_secret';
const refreshToken = jwt.sign({
    sub: '1234567890',
    name: 'John Doe',
    iat: Math.floor(Date.now() / 1000)
}, refreshSecret, {
    algorithm: 'HS256',
    expiresIn: '1d' // 有效时间为1天
});

// 刷新令牌
const newToken = jwt.sign({
    sub: '1234567890',
    name: 'John Doe',
    iat: Math.floor(Date.now() / 1000)
}, secret, {
    algorithm: 'HS256'
});

console.log(newToken);

使用Node.js构建JWT SSO系统

安装依赖

npm install express jsonwebtoken

服务器端代码

const express = require('express');
const jwt = require('jsonwebtoken');
const app = express();
const secret = 'my_secret_key';

app.post('/login', (req, res) => {
    const user = {
        id: 1,
        name: 'John Doe'
    };

    const token = jwt.sign(user, secret, {
        expiresIn: '1h' // 有效时间为1小时
    });

    res.json({ token });
});

app.get('/protected', (req, res) => {
    const token = req.headers.authorization.split(' ')[1];

    jwt.verify(token, secret, (err, decoded) => {
        if (err) {
            return res.status(401).json({ message: 'Unauthorized' });
        }

        res.json({ user: decoded });
    });
});

app.listen(3000, () => {
    console.log('Server running on port 3000');
});

客户端代码

const fetch = require('node-fetch');

fetch('/login', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({ username: 'john.doe', password: 'password123' })
}).then((response) => response.json()).then((data) => {
    console.log(data.token);

    fetch('/protected', {
        headers: {
            'Authorization': 'Bearer ' + data.token
        }
    }).then((response) => response.json()).then((data) => {
        console.log(data.user);
    });
});

使用Spring Boot构建JWT SSO系统

添加依赖

在pom.xml中添加JWT依赖：

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

服务器端代码

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;

import java.util.Date;

@SpringBootApplication
public class JwtDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(JwtDemoApplication.class, args);
    }

    @RestController
    public class AuthController {

        private final String secret = "my_secret_key";

        @PostMapping("/login")
        public String login(@RequestParam String username, @RequestParam String password) {
            if (isValidUser(username, password)) {
                return createToken(username);
            }
            return "Unauthorized";
        }

        private boolean isValidUser(String username, String password) {
            // 实际应用中应从数据库等存储中验证用户
            return username.equals("john.doe") && password.equals("password123");
        }

        private String createToken(String username) {
            return Jwts.builder()
                    .setSubject(username)
                    .setIssuedAt(new Date())
                    .signWith(SignatureAlgorithm.HS256, secret)
                    .setExpiration(new Date(System.currentTimeMillis() + 3600000)) // 有效时间为1小时
                    .compact();
        }

        @GetMapping("/protected")
        public String protectedResource(@RequestHeader("Authorization") String authorization) {
            String token = authorization.replace("Bearer ", "");
            String username = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody().getSubject();
            if (username != null && !username.isEmpty()) {
                return "Hello, " + username;
            }
            return "Unauthorized";
        }
    }
}

客户端代码

const fetch = require('node-fetch');

fetch('/login', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/x-www-form-urlencoded'
    },
    body: 'username=john.doe&password=password123'
}).then((response) => response.json()).then((data) => {
    console.log(data);

    fetch('/protected', {
        headers: {
            'Authorization': 'Bearer ' + data
        }
    }).then((response) => response.text()).then((data) => {
        console.log(data);
    });
});

使用Django构建JWT SSO系统

安装依赖

pip install djangorestframework rest_framework_jwt

服务器端代码

from rest_framework import status
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework_jwt.settings import api_settings
from django.contrib.auth.models import User

jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER

class ObtainAuthToken(APIView):
    def post(self, request):
        username = request.data.get('username')
        password = request.data.get('password')

        if username and password:
            try:
                user = User.objects.get(username=username)
                if user.check_password(password):
                    payload = jwt_payload_handler(user)
                    token = jwt_encode_handler(payload)
                    return Response({'token': token})
                else:
                    return Response({'detail': 'Invalid credentials'}, status=status.HTTP_401_UNAUTHORIZED)
            except User.DoesNotExist:
                return Response({'detail': 'Invalid credentials'}, status=status.HTTP_401_UNAUTHORIZED)
        return Response({'detail': 'Invalid credentials'}, status=status.HTTP_401_UNAUTHORIZED)

class ProtectedResource(APIView):
    def get(self, request):
        token = request.META.get('HTTP_AUTHORIZATION', '').split(' ')[1]
        payload = api_settings.JWT_DECODE_HANDLER(token)
        user = User.objects.get(id=payload['user_id'])
        return Response({'user': user.username})

客户端代码

const fetch = require('node-fetch');

fetch('/api/auth/login/', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({ username: 'john.doe', password: 'password123' })
}).then((response) => response.json()).then((data) => {
    console.log(data.token);

    fetch('/api/protected/', {
        headers: {
            'Authorization': 'JWT ' + data.token
        }
    }).then((response) => response.json()).then((data) => {
        console.log(data.user);
    });
});

令牌签名的重要性

JWT的签名机制是确保令牌完整性和防止篡改的关键。签名通过使用密钥（如HMAC-SHA256）来验证令牌的内容是否被修改。如果密钥丢失或泄露，任何人都可以伪造令牌，因此密钥的安全管理至关重要。

令牌过期与刷新机制

• 过期时间：设置合理的过期时间，避免令牌过长时间有效。
• 刷新令牌：提供刷新令牌机制，当主令牌过期时，可以使用刷新令牌获取新的主令牌。

访问控制策略

• 白名单IP：限制只允许某些IP地址访问资源。
• 访问频率限制：限制每分钟或每小时的请求次数。
• 资源访问权限：根据用户角色和权限控制资源访问。

JWT令牌过期后的处理

当令牌过期时，客户端需要重新获取新的令牌。一种常见的方式是使用刷新令牌（Refresh Token）。

刷新令牌流程

1. 请求刷新令牌：客户端发送刷新令牌进行刷新。
2. 验证刷新令牌：服务器验证刷新令牌的有效性。
3. 生成新令牌：服务器生成新的JWT令牌并返回给客户端。
4. 更新令牌存储：客户端更新存储的JWT令牌。

// 刷新令牌逻辑
const refreshToken = 'refresh_token';

fetch('/refresh-token', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({ token: refreshToken })
}).then((response) => response.json()).then((data) => {
    console.log(data.newToken);
});

令牌泄露的风险与应对措施

令牌泄露可能导致恶意用户访问受保护的资源。为了减少泄露风险，可以采取以下措施：

• 短效期令牌：设置较短的过期时间，减少令牌的有效性时间。
• 刷新令牌分离：刷新令牌和JWT令牌分离存储，避免一起泄露。
• 使用HTTPS：确保所有通信通过HTTPS进行，以加密传输过程中的数据。

不同框架下的JWT使用注意事项

• Node.js：确保使用最新的JWT库版本，并正确处理签名和过期时间。
• Spring Boot：利用Spring Security提供内置的JWT支持，减少手动实现的复杂性。
• Django：结合Django REST Framework使用JWT，确保安全性和方便性。

通过以上介绍和示例代码，你可以了解更多关于JWT单点登录的实现细节和最佳实践。希望这些示例能帮助你更好地理解和应用JWT技术。