python 实现用户登录

cliffordl

已于 2024-06-14 17:38:28 修改

阅读量681

点赞数 2

分类专栏： python 文章标签： python 开发语言

于 2024-04-25 11:25:17 首次发布

本文链接：https://blog.csdn.net/cliffordl/article/details/138183640

版权

python 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

公有云API的认证方式，一般有以下几种认证方式：

Token认证
AK/SK认证
RSA非对称加密方式

1. Token

Token 是一个宽泛的术语，它可以指代任何一种用于身份验证的机制。Token 常常被用在验证和授权流程中。Token 可以有不同的形式和结构，如随机生成的字符串或者特定格式的编码数据。
参考：https://www.zhihu.com/question/364616467
jwt官网：https://jwt.io/#debugger-io

1.1. Token 概述

特点和使用：
不固定格式： Token 可以是任何格式的数据字符串，不仅限于JWT。
存储信息： Token 可能仅作为引用存储在服务器上，服务器通过该引用来获取存储的状态信息。
会话管理： 经统一的身份验证后，Token 用来管理用户会话。
传输方式灵活： 可以通过 HTTP headers、URL 参数或请求体传输。
Token 基本原理：
Token（就是加密的字符串，使用 MD5 等不可逆加密算法，一定要保证唯一性）客户端使用用户名跟密码请求登录服务端收到请求，去验证用户名与密码验证成功，服务端会签发一个 Token 保存到（Session,redis,mysql…）中，然后再把这个 Token 发送给客户端客户端收到 Token 以后可以把它存储起来，比如放在 Cookie 里或者 Local Storage 里客户端每次向服务端请求资源的时候需要带着服务端签发的 Token服务端收到请求，验证密客户端请求里面带着的 Token 和服务器中保存的 Token 进行对比效验, 如果验证成功，就向客户端返回请求
优点：
可以隐藏真实数据，安全系数高
适用于分布式/微服务
Token支持手动控制，过期、吊销等
可以实时查询现有Token
缺点：
存放在数据库或者redis，依赖服务器资源
效率相对JWT比较低

1.2. JWT 是什么

JSON Web Token (JWT)是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的。

1.2.1. 作用

JWT 的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源。比如用在用户登录上。
JWT 最重要的作用就是对 token 信息的防伪作用。

1.2.2. JWT 组成

一个 JWT 由三部分组成：JWT 头、有效载荷、签名哈希，这三部分分别进行 base64url 编码，之间用“ .” 相互连接，如下，一个JWT字符串：
JWT头
JWT 头部分是一个描述 JWT 元数据的JSON对象，包含两部分信息：

声明类型，这里是“JWT”
使用的加密算法，如HMAC、SHA256、RSA，默认为HMAC SHA256（写为HS256）
完整的头部如下面的 JSON

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

这部分 JSON 对象使用 Base64 URL 算法转换为字符串保存
有效载荷
有效载荷，是 JWT 的主体内容部分，也是一个 JSON 对象，包含需要传递的数据。 JWT 指定七个默认字段供选择。

iss # jwt签发者
sub # 主题
aud # 接收jwt的一方
exp # jwt的过期时间，这个过期时间必须要大于签发时间
nbf # 定义在什么时间之前，该jwt都是不可用的.
iat # jwt的签发时间
jti # jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击。

也可以自定义字段，如：

{
  "name": "Ann",
  "role": "manager",
}

这部分 JSON 对象也使用 Base64 URL 算法转换为字符串保存，因此是未加密的，所以注意不要放敏感信息（如密码）
签名哈希
签名哈希部分是对上面两部分数据签名，通过指定的算法生成哈希，以确保数据不会被篡改。
首先，需要指定一个密码（secret）。该密码仅仅为保存在服务器中，并且不能向用户公开。然后，使用标头中指定的签名算法（默认为SHA256）根据下述公式生成签名。

HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(claims), secret)    ==>   签名hash

签名的作用
签名的过程实际上是对头部和负载内容进行签名，防止内容被窜改。假如有人对头部和负载的内容解码之后进行修改，再进行编码，最后加上之前的签名组合形成新的 JWT 的话，这样服务器端可以判断出新的头部和负载形成的签名和 JWT 附带上的签名是不一样的，这样服务器端就可以知道数据被篡改了。（这是由于签名产生，需要结合头部、负载、以及密钥来生成，而密钥保存在服务器端，无法获取）在计算出签名哈希后，JWT头，有效载荷和签名哈希的三个部分组合成一个字符串，每个部分用"."分隔，就构成整个 JWT 对象。

1.2.3. JWT 单点登录流程

首次登陆，客户端向服务器请求令牌，服务器接收客户端发送的用户凭证（如用户名、密码）进行身份校验，校验成功后，服务端生成 JWT（有过期时间），将其发送给客户端。
客户端接收 JWT 令牌后，存储它（通常，客户端将令牌存储在 Cookie 中）。
之后客户端每次访问服务器的应用资源，都会将 JWT 令牌发送给服务器，用以验证客户端身份。
服务端收到 JWT 令牌，对其进行验证，验证通过，则认为客户端已经被授权访问应用资源，否则拒绝客户端访问。
假如令牌过期，客户端需要重新向服务器端请求新令牌，然后再进行资源访问。

1.2.4. 优缺点

无状态： JWT 自身包含了身份验证所需要的所有信息，因此，我们的服务器不需要存储 Session 信息。这显然增加了系统的可用性和伸缩性，大大减轻了服务端的压力。
不过，也正是由于 JWT 的无状态，也导致了它最大的缺点：不可控！
就比如说，我们想要在 JWT 有效期内废弃一个 JWT 或者更改它的权限的话，并不会立即生效，通常需要等到有效期过后才可以。
再比如说，当用户 Logout 的话，JWT 也还有效。除非，我们在后端增加额外的处理逻辑比如将失效的 JWT 存储起来，后端先验证 JWT 是否有效再进行处理。
有效的避免的 CSRF 攻击

1.3. jwt 实践

1.3.1. 环境安装

pip install pyjwt

1.3.2. 生成 JWT

from jose import JWTError, jwt
import datetime

# 密钥，用于签名和验证JWT
secret_key = 'your-secret-key'

# 载荷，即JWT中包含的信息
payload = {
    'user_id': 112233445566,
    'username': 'jack',
    'exp': datetime.datetime.utcnow() + datetime.timedelta(days=1)
}

# 生成JWT
token = jwt.encode(payload, secret_key, algorithm='HS256')
print('Generated JWT:', token)

运行结果：

Generated JWT: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoxMTIyMzM0NDU1NjYsInVzZXJuYW1lIjoiamFjayIsImV4cCI6MTcxNDExNDU3OH0.AKvwYltVfQ14b9zzS6ILC9NWf9kUiEyedL2aJ_8vF9s

登录官网验证：
官网地址：https://jwt.io/#debugger-io
在这里插入图片描述

1.3.3. 验证 JWT

from jose import JWTError, jwt
import datetime

# # 密钥，用于签名和验证JWT
secret_key = 'your-secret-key'

# 待验证的JWT
# received_token = 'your-received-token'
received_token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoxMTIyMzM0NDU1NjYsInVzZXJuYW1lIjoiamFjayIsImV4cCI6MTcxNDExNDU3OH0.AKvwYltVfQ14b9zzS6ILC9NWf9kUiEyedL2aJ_8vF9s'

try:
    # 验证JWT
    decoded_payload = jwt.decode(received_token, secret_key, algorithms=['HS256'])
    print('Decoded Payload:', decoded_payload)
except jwt.ExpiredSignatureError:
    print('JWT has expired.')
except jwt.InvalidTokenError:
    print('Invalid JWT.')

运行结果：

Decoded Payload: {'user_id': 112233445566, 'username': 'jack', 'exp': 1714114578}

1.3.4. 高级选项与定制

PyJWT还提供了一系列高级选项和定制功能，例如自定义过期时间、指定算法、添加额外的头部信息等。

import jwt
import datetime

# 密钥，用于签名和验证JWT
secret_key = 'your-secret-key'

# 载荷，即JWT中包含的信息
payload = {
    'user_id': 112233445566,
    'username': 'jack',
}

# 自定义过期时间为10分钟后
expiration_time = datetime.datetime.utcnow() + datetime.timedelta(minutes=10)

# 生成JWT并指定算法和额外的头部信息
token = jwt.encode(payload, secret_key, algorithm='HS256', headers={'kid': 'key-id'}, exp=expiration_time)
print('Generated JWT:', token)

运行结果：

Generated JWT: eyJhbGciOiJIUzI1NiIsImtpZCI6ImtleS1pZCIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoxMTIyMzM0NDU1NjYsInVzZXJuYW1lIjoiamFjayJ9.ZYaXfdWodS5Nh0D0z-W5A6IhN9l6_ZHlIgechMLtB2w

登录官网验证：
官网地址：https://jwt.io/#debugger-io
在这里插入图片描述

1.4. 实例1 面向对象

from jose import JWTError, jwt
import datetime

class JWTToken(object):
    def __init__(self) -> None:
        # 密钥，用于签名和验证JWT
        self._secret_key = 'a9d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e8'
        self._algorithm = "HS256"
        pass

    # payload: 载荷，即JWT中包含的信息
    def jwt_encode(self, payload: dict):
        # 生成JWT
        token = jwt.encode(payload, self._secret_key, algorithm=self._algorithm)
        print('Generated JWT:', token)
        return token

    def jwt_decode(self, token: str):
        payload = ""
        try:
            # 验证JWT
            payload = jwt.decode(token, self._secret_key, algorithms=[self._algorithm])
            print('Decoded Payload:', payload)
        except jwt.ExpiredSignatureError:
            print('JWT has expired.')
        except jwt.InvalidTokenError:
            print('Invalid JWT.')
        return payload

if __name__ == '__main__':
    jwt_token = JWTToken()
   
    payload = {
        'user_id': 112233445566,
        'username': 'jack',
        'jti': 'once',
        'iss': 'server_id',
        'exp': datetime.datetime.utcnow() + datetime.timedelta(days=1)
    }
    access_token = jwt_token.jwt_encode(payload=payload)

    # 服务器验证刷新令牌的有效性后，生成新的访问令牌，并返回给客户端
    payload = {
        'username': 'jack',
        'sub': 'refresh'
    }
    refresh_token = jwt_token.jwt_encode(payload=payload)
    
    jwt_token.jwt_decode(token=access_token)
    jwt_token.jwt_decode(token=refresh_token)

运行结果：

Generated JWT: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoxMTIyMzM0NDU1NjYsInVzZXJuYW1lIjoiamFjayIsImp0aSI6Im9uY2UiLCJpc3MiOiJzZXJ2ZXJfaWQiLCJleHAiOjE3MTQxMTg3MjR9.YsFTI8KwHeQFics2g-DdiN01a8J7xXeV_ExTf1cviWI
Generated JWT: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6ImphY2siLCJzdWIiOiJyZWZyZXNoIn0.NgHJ2NCd72NxscKZboYGKJg2P_GSQLu1Ku7WINrABXE
Decoded Payload: {'user_id': 112233445566, 'username': 'jack', 'jti': 'once', 'iss': 'server_id', 'exp': 1714118724}
Decoded Payload: {'username': 'jack', 'sub': 'refresh'}

2. AK/SK

2.1. AK/SK 原理

云主机需要通过使用 Access Key Id / Secret Access Key 加密的方法来验证某个请求的发送者身份。
Access Key Id（AK）用于标识用户，
Secret Access Key（SK）是用户用于加密认证字符串，也是云厂商用来验证认证字符串的密钥，SK 必须保密。
AK/SK 原理使用对称加解密。

2.1.1. AK/SK 使用机制

云主机接收到用户的请求后，系统将使用同样的AK/SK和同样的认证机制生成认证字符串，并与用户请求中包含的认证字符串比对。如果认证字符串相同，系统认为用户拥有指定的操作权限；如果认证字符串不同，系统将忽略该操作并返回错误码。

2.1.2. 流程

客户端：
AK/SK 获取应该通过线下获取。

构建http请求（包含 access key(AK)）；
使用请求内容和 secret access key(SK) 计算的签名（signature）；
将组合好的 Authorization（包含 access key，expire_time，signature) 加入 http 请求的 Header，发送请求到服务端。

服务端：
判断用户请求中是否包含 Authorization 认证字符串。如果包含认证字符串，则执行下一步操作。

根据客户端发送的 access key(AK) 查找数据库得到对应的 secret access key(SK)；
使用同样的算法将请求内容和 secret access key一起计算签名（signature），与客户端步骤2相同；
对比用户发送的签名和服务端计算的签名，两者相同则认证通过，否则失败。

2.1.3. 签名计算方式

Signature 计算方式的伪代码

signature = HexEncode(sha1(Secret Access Key + ExpireTime + URL))

sha1 指密钥相关的哈希运算，HexEncode 指转十六进制字符串，如果对应的语言 sha1 计算的结果已经是16进制的字符串，则无需再次转换为16进制的字符串。
ExpireTime是以秒为单位的时间戳字符串，表示该 Signature 的过期时间；例如： 1860490539。
URL不包含host内容，一般以/device-manager-services开头， URL包含query参数例如： /device-manager-services/v0/log/getMessageLog?start_time=1630490339&end_time=1860490539&size=20&offset=0

Authorization header创建伪码

Authorization: Access=[Access Key Id], ExpireTime=[expire_time], Signature=[signature]

需要注意的是：Access之前没有逗号，但是 ExpireTime 与 Signature 之前需要使用逗号加空格隔开。

2.2. AK/SK 实践

https://docs.daocloud.io/skoala/best-practice/ak-sk-demo.html#_2

3. 非对称加密 rsa

五种常见的用户密码泄露方式：
https://cloud.tencent.com/developer/article/1903494
JWT认证中如何防止他人冒充token
https://www.zhihu.com/question/364616467

3.1. 环境安装

pip install pycryptodome # windows上使用的是pycryptodome包。
pip install pycryptodome # Linux上使用pycrypto包。

3.2. 实例1 面向对象

# -*- coding: utf-8 -*-
import base64
from Crypto import Random
from Crypto.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5
from Crypto.PublicKey import RSA

class RSACrypto(object):
    def __init__(self):
        print("CipherTool init")

    # 获取公钥和私钥
    def rsa_keys(self):
        random_generator = Random.new().read
        rsa = RSA.generate(1024, random_generator)

        rsa_private_key = rsa.exportKey()
        rsa_public_key = rsa.publickey().exportKey()
        return {"rsa_private_key":rsa_private_key, "rsa_public_key":rsa_public_key}

    # 用公钥进行加密
    def ras_encrypt(self, public_key: str, clear_text:str):
        # 加密函数 encrypt 需要使用 bytes 类型数据
        clear_text = clear_text.encode(encoding="utf-8")
        rsakey = RSA.importKey(public_key)
        cipher = Cipher_pkcs1_v1_5.new(rsakey)
        cipher_text = cipher.encrypt(clear_text)
        # cipher_text = base64.b64encode(cipher.encrypt(message))
        # print("", cipher_text)
        return cipher_text

    # 用私钥进行解密
    def ras_decrypt(self, private_key, cipher_text: bytes):
        rsakey = RSA.importKey(private_key)
        cipher = Cipher_pkcs1_v1_5.new(rsakey)
        # random_generator = Random.new().read
        clear_text = cipher.decrypt(cipher_text, None)
        # text = cipher.decrypt(base64.b64decode(cipher_text), None)
        # print(clear_text.decode())
        return clear_text.decode(encoding="utf-8")

if __name__ == '__main__':
    rsa_crypto = RSACrypto()

    rsa_keys = rsa_crypto.rsa_keys()
    print("rsa_private_key:", rsa_keys["rsa_private_key"])
    print("rsa_public_key:", rsa_keys["rsa_public_key"])

    clear_text = "hello world"
    cipher_text = rsa_crypto.ras_encrypt(public_key=rsa_keys["rsa_public_key"], clear_text=clear_text)
    print("cipher_text:", cipher_text)

    clear_text = rsa_crypto.ras_decrypt(private_key=rsa_keys["rsa_private_key"], cipher_text=cipher_text)
    print("clear_text:", clear_text)

运行结果：

CipherTool init
rsa_private_key: b'-----BEGIN RSA PRIVATE KEY-----\nMIICWwIBAAKBgQCxsXGQv4tuhdngOHQvzV6QLfiZ7aK5FL5goOVpOr4vceDZpreo\nIhPvpjj8W6gyOqBTM4D6Im/x7OWOYfB9zVwpbLYPftePK/NBbqtfWqkaLOToEbCi\ngeybrDyJBS2vqb7RLbEkiXkPgKxK7oNk/QxdKnUc32GL81jCZKB4pkBU8QIDAQAB\nAoGAEuU0l1jXAdy363D1YfPrv1c0HWI4sIe1Kt9RJdx6Rt9MMrjYxMdC6XP6kVNJ\n0nWLgO10JKUu1EIFsxtVEHua9htYlTX/m3eVz+8d30uJiSA1IvWWwNQ531k8H5Fq\nu8Vfj36JDpN1q6f4cIDiKh+7CjcK3G3jrSUasr2w8tZBA8UCQQDO1Bvsa9k27rLE\nBUYXdI/f267/OEFHZX/KawdmFmXh31dPyDozsx2vDccDYnJdpK/ykYiRKYJTzQ5K\nnvhb0RC/AkEA2/AcQIKnCTYXr/t9iBaBDaj5M51t3azG6YPk96VVBHjYhvCgHPkl\nz47/AKrGGtNYp0OVv1HADYiM0Yp2leRWTwJAN6a3BLxYLAG6NCg/HdyNQey4f4/B\ncNaMtghqazunmkkgEyWLE5IkcI/CdtSsdSn09c3W80g5+xZ3u/heV0Y/vQJADJu2\nMuiKhNeqAfer2ZpYqZzPNGtI+hVGjep2vM+okQoQd6Phued6iGyNJ8+ibbVB9szE\nD+Sy2tPCJt0GMU+WtwJAclT51+DzFVscyp0V13ocoNacTZCqJ99f8o6sEnv8znId\nEIdFS9ALoo+U2VXG815acsZLmw/2dpqiwYS5nuryIA==\n-----END RSA PRIVATE KEY-----'
rsa_public_key: b'-----BEGIN PUBLIC KEY-----\nMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCxsXGQv4tuhdngOHQvzV6QLfiZ\n7aK5FL5goOVpOr4vceDZpreoIhPvpjj8W6gyOqBTM4D6Im/x7OWOYfB9zVwpbLYP\nftePK/NBbqtfWqkaLOToEbCigeybrDyJBS2vqb7RLbEkiXkPgKxK7oNk/QxdKnUc\n32GL81jCZKB4pkBU8QIDAQAB\n-----END PUBLIC KEY-----'
cipher_text: b'YG\x97\x87\xb5\xf4_\xd4\xb1\x0bR\xa0\xe8\xf6\x80x\x94+\xc4\x9a\r0\x91\xab\x95oo\xe9\xcf\xaf\xacl\xd5\x97\xe8$_5W\xc66\xa2K\x90a\x8d\x1b>\x1a\xa2\x16 \xceY\x85\x83\xa8w\x94K\xe4\x05\x8c\xa2+\xf3\xb0o\x07"\xaf\x8f\x88\x11Om\x02n\xe3\xed\xe9L\xb7( \xbfQV\xda\xd9\xed]\xa0B\x8dv\xc3\xb9\xab\xad\xdb.\xe4YB\xa4D\x8c\\ \xa9h\x97\xc2\x13\xff\n\xd0\x9a\x04\x9f\xdb\xec8\xb4O-\t'
clear_text: hello world

3.3. 实例2 面向过程

message = "hello world"
message = message.encode()

# 获取公钥和私钥
random_generator = Random.new().read
rsa = RSA.generate(1024, random_generator)

rsa_private_key = rsa.exportKey()
rsa_public_key = rsa.publickey().exportKey()
print("private key:", len(rsa_private_key), rsa_private_key)
print("public key:", len(rsa_public_key), rsa_public_key)

# 用公钥进行加密
rsakey = RSA.importKey(rsa_public_key)
cipher = Cipher_pkcs1_v1_5.new(rsakey)
cipher_text = cipher.encrypt(message)
# cipher_text = base64.b64encode(cipher.encrypt(message))
# print("cipher_text:", cipher_text)

# 用私钥进行解密
rsakey = RSA.importKey(rsa_private_key)
cipher = Cipher_pkcs1_v1_5.new(rsakey)
clear_text = cipher.decrypt(cipher_text, None)
# text = cipher.decrypt(base64.b64decode(cipher_text), None)
print("clear_text:", clear_text.decode())

运行结果：

private key: 886 b'-----BEGIN RSA PRIVATE KEY-----\nMIICXAIBAAKBgQC4bZYjXWsNe4U4KZWSR3bykL5I55AlxVQrPabp2TmGkWqPffj2\n7gmMIlYsSJnm/RXqlGjBhSeQwrGPDgGH+d89w9m+1zI1S+l4D/w/jtWxEPMA9SqT\n95P5CPvBWt9mdUim2gso1lF3ZQ1wDBTbgns5qYk8zcIfXN0nvFvH/tZZKQIDAQAB\nAoGAEKQmw3sm8Tj/jNFHw0K6i2mfGeH3IklbbmlqObiVlbxiUp9JyzIwX1orz2Qf\nqvWUOC37A9c5ejjvH5ribXwQ9hDEE1+cmH1jfsEtoEPIR00QBUOuwT2jwwUthdc/\nWMQIlwjNTXKyuL/4s1qEZiLp3h9wnFv0dMOgOF+DbEIUQucCQQC/sPcnlMOmhCFo\njuuwKvlcE8NmHtwIGOZHlqUBLm1LKMSP4U1Rsm9ezd20Ud2ocVAlFCqFuSsCGuHm\nY6AFBw47AkEA9kzVz/ReDsQpJdzpfJb5MNI9NCJicNVe8yflk2lTlR+6v42yZEwc\nMIYfHXAl519CJFd4Hr5a4psjUq1hmINL6wJAamT3mTF5sneN73G8ISiJBPE3N/wS\n1i+zyLI1XUV+hgPXraA4gQrPw8fxsP7rT22tNRdPTq9qzp1LGsva6k9zNwJBANeP\n27nLd96YlCLNO5SNVb8C4goU5e8274kErAreLgbf5EPuMelSK4HUgLr1AleDqZHA\n9CKEG2skuD+N+1LN5s0CQEVkeiPTlEM7hg+HG7fnE0Qzin4S+0JJ14V3fnKbJ4fG\n+PlW9tj2Rq4l2zNDJ+AiDNfv0JkYdrVbBqBXyVU/Ofs=\n-----END RSA PRIVATE KEY-----'
public key: 271 b'-----BEGIN PUBLIC KEY-----\nMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC4bZYjXWsNe4U4KZWSR3bykL5I\n55AlxVQrPabp2TmGkWqPffj27gmMIlYsSJnm/RXqlGjBhSeQwrGPDgGH+d89w9m+\n1zI1S+l4D/w/jtWxEPMA9SqT95P5CPvBWt9mdUim2gso1lF3ZQ1wDBTbgns5qYk8\nzcIfXN0nvFvH/tZZKQIDAQAB\n-----END PUBLIC KEY-----'
clear_text: hello world

cliffordl

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
python 实现用户登录

特点和使用：Token 可以是任何格式的数据字符串，不仅限于JWT。Token 可能仅作为引用存储在服务器上，服务器通过该引用来获取存储的状态信息。经统一的身份验证后，Token 用来管理用户会话。可以通过 HTTP headers、URL 参数或请求体传输。
复制链接

扫一扫