深入了解六种身份验证方法

目录

• JWT
• OAuth
• Basic Authentication
• Token authentication
• Cookie-Based Authentication
• SAML Authentication
• OpenID Authentication

JWT

JWT（JSON Web Token） 是一种开放标准（RFC 7519），用于在网络应用环境中安全地传输信息。它主要用于身份验证和信息交换。JWT 的核心思想是将身份和授权信息嵌入到一个签名的 JSON 对象中，这样它可以被安全地传输和验证。

JWT 的结构

JWT 通常由三部分组成：

1. 头部（Header）：头部通常包含令牌的类型（即 JWT）和所使用的签名算法（例如 HMAC SHA256 或 RSA）。

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

2. 负载（Payload）：

   • 负载部分包含了要传输的数据（称为声明）。声明有三种类型：
     • 注册声明（Registered Claims）：预定义的声明，如 iss（发行者）、exp（过期时间）等。
     • 公共声明（Public Claims）：可以自定义的声明，但应避免与其他声明冲突。
     • 私有声明（Private Claims）：用户定义的声明，通常用于业务逻辑中。

   {
     "sub": "1234567890", // 表示令牌的主体，即用户的唯一标识符。在这个例子中，"1234567890" 是用户的 ID 或其他唯一标识符。
     "name": "John Doe", // 这是一个公共声明，表示用户的名称。在这个例子中，"John Doe" 是用户的姓名。
     "iat": 1516239022 // 表示令牌的发行时间，是一个 Unix 时间戳（自1970年1月1日以来的秒数）。在这个例子中，1516239022 对应于某个具体的日期和时间，表示这个令牌是在该时间点生成的。
   }
   

3. 签名（Signature）：为了确保 JWT 的完整性和真实性，需要对头部和负载进行签名。签名的生成方式取决于头部中指定的算法。

   HMACSHA256(
     base64UrlEncode(header) + "." +
     base64UrlEncode(payload),
     secret)
   

JWT 的验证流程

1. 客户端登录：

   • 用户向服务器提供凭证（如用户名和密码）。
   • 服务器验证凭证，并生成一个 JWT 作为响应。

2. 客户端存储 JWT：

   • 客户端将 JWT 存储在本地（例如在浏览器的 localStorage 或 sessionStorage 中）。

3. 客户端发送请求：

   • 每次客户端向受保护的资源发送请求时，都会将 JWT 附加到请求头部（通常为 Authorization 字段）。

   示例：

   GET /protected-resource HTTP/1.1
   Host: example.com
   Authorization: Bearer <your_jwt>
   

4. 服务器验证 JWT：

   • 服务器从请求中提取 JWT，并对其进行解码和验证。
   • 验证包括：检查签名是否有效、检查 JWT 是否过期、验证声明（如用户角色等）。

5. 访问授权：

   • 如果 JWT 验证通过，服务器允许访问受保护的资源。

示例代码

以下是一个简单的 JWT 验证示例（使用 Node.js 和 jsonwebtoken 库）：

const jwt = require('jsonwebtoken');
const secret = 'your-very-secure-secret';

// 生成 JWT
function generateToken(payload) {
  return jwt.sign(payload, secret, { expiresIn: '1h' });
}

// 验证 JWT
function verifyToken(token) {
  try {
    return jwt.verify(token, secret);
  } catch (err) {
    throw new Error('Invalid token');
  }
}

// 示例用法
const token = generateToken({ userId: '1234' });
console.log('Generated Token:', token);

try {
  const decoded = verifyToken(token);
  console.log('Decoded Token:', decoded);
} catch (err) {
  console.error(err.message);
}

OAuth

OAuth（Open Authorization）是一种开放标准，用于在第三方应用程序和资源提供者之间授权访问资源，而无需暴露用户的凭据。OAuth 主要用于访问授权和令牌管理，允许用户通过授权第三方应用来访问其受保护的资源（如数据），而不直接分享用户名和密码。

OAuth 的基本原理

1. 授权服务器（Authorization Server）：负责验证用户身份并颁发授权令牌（Access Token）。授权服务器可以是单独的服务器，也可以与资源服务器合并。

2. 资源服务器（Resource Server）：托管受保护的资源，并验证访问令牌的有效性。资源服务器通常会向授权服务器验证令牌的合法性。

3. 客户端（Client）：需要访问受保护资源的应用程序。客户端通常会通过授权服务器获得访问令牌，然后使用该令牌访问资源服务器上的资源。

4. 资源拥有者（Resource Owner）：资源的拥有者，通常是最终用户，他们授权客户端访问他们的数据。

OAuth 授权流程

1. 用户请求授权：用户在客户端应用程序中请求访问受保护资源。

2. 客户端重定向到授权服务器：客户端将用户重定向到授权服务器，并提供客户端标识符（client_id）、重定向 URI（redirect_uri）以及请求的权限范围（scope）。

3. 用户授权：用户在授权服务器上登录并同意授权客户端访问资源。授权服务器将授权码（authorization code）发送到客户端的重定向 URI。

4. 客户端请求令牌：客户端使用授权码向授权服务器请求访问令牌，并提供客户端密钥（client_secret）和授权码。

5. 授权服务器颁发令牌：授权服务器验证客户端和授权码的有效性后，颁发访问令牌（access token）和可选的刷新令牌（refresh token）。

6. 客户端访问资源：客户端使用访问令牌向资源服务器请求受保护的资源。资源服务器验证令牌的有效性后，返回资源数据。

7. 令牌刷新（可选）：如果访问令牌过期，客户端可以使用刷新令牌向授权服务器请求新的访问令牌。

示例代码

以下是使用 OAuth 2.0 的示例代码，展示了如何通过授权码流程获取访问令牌。

1. 获取授权码

import requests
from urllib.parse import urlencode

# 配置参数
client_id = 'your_client_id'
redirect_uri = 'https://yourapp.com/callback'
scope = 'read write'
authorization_endpoint = 'https://authorization-server.com/auth'

# 构造授权请求 URL
auth_url = f"{authorization_endpoint}?{urlencode({
    'response_type': 'code',
    'client_id': client_id,
    'redirect_uri': redirect_uri,
    'scope': scope
})}"

print(f"Please go to the following URL and authorize the application: {auth_url}")

2. 交换授权码获取访问令牌

import requests

# 配置参数
client_id = 'your_client_id'
client_secret = 'your_client_secret'
redirect_uri = 'https://yourapp.com/callback'
authorization_code = 'authorization_code_received'
token_endpoint = 'https://authorization-server.com/token'

# 请求访问令牌
response = requests.post(token_endpoint, data={
    'grant_type': 'authorization_code',
    'code': authorization_code,
    'redirect_uri': redirect_uri,
    'client_id': client_id,
    'client_secret': client_secret
})

# 解析响应
tokens = response.json()
access_token = tokens['access_token']
print(f"Access Token: {access_token}")

3. 使用访问令牌访问资源

import requests

# 配置参数
resource_endpoint = 'https://resource-server.com/data'
access_token = 'your_access_token'

# 请求受保护的资源
response = requests.get(resource_endpoint, headers={
    'Authorization': f'Bearer {access_token}'
})

# 处理响应
data = response.json()
print(f"Resource Data: {data}")

Basic Authentication

Basic Authentication 是一种简单的 HTTP 身份验证方法，它通过将用户名和密码编码为 Base64 字符串并将其附加在 HTTP 请求头中进行身份验证。尽管这种方法易于实现，但它的安全性较低，因为凭据可以被容易地解码，因此通常与 HTTPS 结合使用以加密传输过程中的数据。

原理与工作流程

1. 客户端请求访问受保护资源：客户端向服务器发送请求，以访问受保护的资源。

2. 服务器返回 401 未授权状态：如果客户端未提供凭据或提供的凭据无效，服务器会返回 401 Unauthorized 响应，并在响应头中包含 WWW-Authenticate: Basic，提示客户端进行基本身份验证。

3. 客户端提供凭据：客户端将用户名和密码组合成一个字符串（格式为 username:password），并使用 Base64 编码该字符串。然后将编码后的字符串添加到 Authorization 请求头中，格式为 Authorization: Basic <Base64 编码后的凭据>。

4. 服务器验证凭据：服务器解码 Base64 字符串，获取用户名和密码，并验证其是否正确。如果正确，则允许访问受保护资源；如果不正确，则再次返回 401 Unauthorized。

5. 客户端访问受保护资源：一旦验证通过，服务器返回请求的资源，客户端即可访问。

示例代码

以下是如何在服务器端和客户端使用 Basic Authentication 的示例。

服务器端：Node.js 示例

使用 Express.js 框架来实现一个简单的 Basic Authentication 服务器。

const express = require('express');
const app = express();

// 简单的用户数据示例
const users = {
  admin: 'password123',
  user: 'userpass'
};

// 中间件进行 Basic Authentication
app.use((req, res, next) => {
  const authHeader = req.headers['authorization'];
  
  if (!authHeader) {
    res.setHeader('WWW-Authenticate', 'Basic');
    return res.status(401).send('Authentication required.');
  }

  const auth = authHeader.split(' ')[1];
  const [username, password] = Buffer.from(auth, 'base64').toString().split(':');

  if (users[username] && users[username] === password) {
    // 认证成功
    return next();
  }

  // 认证失败
  res.setHeader('WWW-Authenticate', 'Basic');
  return res.status(401).send('Invalid credentials.');
});

// 受保护的路由
app.get('/', (req, res) => {
  res.send('Hello, authenticated user!');
});

// 启动服务器
app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

客户端：使用 cURL 进行请求

使用 cURL 模拟客户端请求：

# 未提供凭据，返回 401 Unauthorized
curl http://localhost:3000/

# 提供正确凭据，访问受保护资源
curl -u admin:password123 http://localhost:3000/

# 提供错误凭据，返回 401 Unauthorized
curl -u admin:wrongpassword http://localhost:3000/

注意事项

1. 安全性：Basic Authentication 中的凭据仅使用 Base64 编码，而非加密，因此在传输过程中容易被拦截并解码。为提高安全性，应始终通过 HTTPS 进行传输。

2. 凭据缓存：浏览器通常会缓存凭据，因此需要小心处理注销或重新认证的场景。

3. 使用场景：由于其简单性，Basic Authentication 常用于简单的 API 保护或内部工具，但在公共或生产环境中，应考虑使用更安全的身份验证方法，如 OAuth 或 JWT。

Token authentication

Token Authentication 是一种常见的身份验证机制，特别适用于无状态的Web应用程序和API。它通过分发、验证令牌（Token）来实现用户身份的确认。

原理

1. 用户认证：

   • 用户提供用户名和密码进行登录。
   • 服务器验证用户的凭据，如果成功，服务器会生成一个令牌（Token），通常是JWT（JSON Web Token）。

2. 令牌分发：

   • 服务器将生成的令牌返回给客户端。
   • 客户端将令牌存储起来，通常存储在浏览器的 localStorage 或 sessionStorage 中。

3. 请求资源：

   • 在后续的每次请求中，客户端需要在 Authorization 头中附带这个令牌。
   • 服务器接收到请求后，会验证令牌的有效性。

4. 令牌验证：

   • 服务器解码并验证令牌的签名，以确保令牌未被篡改，并且未过期。
   • 如果令牌有效，服务器将继续处理请求并返回相应的数据。

5. 令牌过期：

   • 令牌通常有一个过期时间（如15分钟、1小时）。
   • 当令牌过期时，用户需要重新登录或使用刷新令牌（Refresh Token）获取新的令牌。

优点

• 无状态：令牌认证不需要服务器存储会话状态，适合分布式系统。
• 跨域支持：令牌可以用于跨域请求，无需跨域资源共享（CORS）配置。
• 灵活性：令牌可以携带额外信息，如用户角色、权限等，增强了安全性和灵活性。

Token Authentication 实例代码

以下是一个基于Node.js和Express的简化示例，演示如何实现Token Authentication：

1. 安装依赖

npm install express jsonwebtoken body-parser

2. 创建服务器

const express = require('express');
const jwt = require('jsonwebtoken');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json());

const SECRET_KEY = 'your-secret-key';
const users = [{ username: 'user1', password: 'password1' }];

// 用户登录，生成并返回令牌
app.post('/login', (req, res) => {
  const { username, password } = req.body;

  const user = users.find(u => u.username === username && u.password === password);
  if (!user) {
    return res.status(401).json({ message: 'Invalid credentials' });
  }

  const token = jwt.sign({ username: user.username }, SECRET_KEY, { expiresIn: '1h' });
  res.json({ token });
});

// 受保护的路由，验证令牌
app.get('/protected', (req, res) => {
  const token = req.headers['authorization'];

  if (!token) {
    return res.status(403).json({ message: 'Token is required' });
  }

  try {
    const decoded = jwt.verify(token.split(' ')[1], SECRET_KEY);
    res.json({ message: 'Protected content', user: decoded.username });
  } catch (err) {
    res.status(401).json({ message: 'Invalid or expired token' });
  }
});

app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

3. 运行步骤

1. 启动服务器：

   node server.js
   

2. 登录获取令牌：

   • 通过 POST /login 请求发送用户凭据（用户名和密码）。
   • 成功后，服务器会返回一个JWT令牌。

3. 访问受保护资源：

   • 通过 GET /protected 请求，并在 Authorization 头中附带 Bearer <token>。
   • 如果令牌有效，服务器返回受保护的资源信息。

注意事项

• 令牌安全性：妥善管理SECRET_KEY，避免泄露。
• 令牌存储：令牌存储在客户端时，应防止XSS攻击。
• 令牌刷新：当令牌过期时，使用刷新令牌或重新登录获取新令牌。

Cookie-Based Authentication

Cookie-Based Authentication 是一种传统且常用的身份验证方式，主要用于 Web 应用程序中。它通过在客户端和服务器之间传递 Cookie 来维护用户的会话状态。下面是其工作原理、步骤以及示例代码的详细介绍。

原理

Cookie-Based Authentication 的基本原理是，用户在登录成功后，服务器生成一个会话标识符（Session ID），并将其存储在 Cookie 中，然后发送给客户端。客户端每次向服务器发送请求时都会自动携带这个 Cookie，服务器通过验证 Cookie 中的 Session ID 来识别用户的身份。

步骤

1. 用户登录：用户向服务器发送登录请求，通常包含用户名和密码。

2. 服务器验证凭据：服务器验证用户名和密码。如果验证成功，服务器会生成一个唯一的 Session ID，并在服务器端创建一个会话（Session），将用户信息与该 Session ID 关联起来。

3. 创建 Cookie：服务器将生成的 Session ID 通过 Set-Cookie HTTP 头发送给客户端。客户端浏览器会将这个 Cookie 存储下来。

4. 客户端保存 Cookie：客户端保存 Cookie，之后每次请求都会自动将 Cookie 中的 Session ID 发送给服务器。

5. 服务器验证 Cookie：服务器在接收到请求时，检查请求中的 Cookie。如果 Cookie 中的 Session ID 在服务器端存在且有效，服务器将认为用户已通过身份验证，并允许继续访问受保护的资源。

6. 用户注销：用户可以选择注销，服务器会销毁对应的会话，并可能通知客户端删除或过期 Cookie。

示例代码

下面是一个使用 Node.js 和 Express 的示例，展示如何实现 Cookie-Based Authentication。

服务器端代码（Node.js 和 Express）

const express = require('express');
const bodyParser = require('body-parser');
const session = require('express-session');

const app = express();
app.use(bodyParser.urlencoded({ extended: true }));

// 配置 Session 中间件
app.use(session({
  secret: 'your_secret_key', // 用于加密 Session ID 的密钥
  resave: false,
  saveUninitialized: true,
  cookie: { secure: false } // secure: true 适用于 HTTPS
}));

// 用户数据库（示例）
const users = {
  'user1': 'password1',
  'user2': 'password2'
};

// 登录路由
app.post('/login', (req, res) => {
  const { username, password } = req.body;

  if (users[username] && users[username] === password) {
    // 验证成功，创建会话
    req.session.user = username;
    res.send('Login successful!');
  } else {
    res.status(401).send('Invalid credentials');
  }
});

// 受保护的路由
app.get('/dashboard', (req, res) => {
  if (req.session.user) {
    res.send(`Welcome, ${req.session.user}`);
  } else {
    res.status(401).send('Please log in');
  }
});

// 注销路由
app.post('/logout', (req, res) => {
  req.session.destroy((err) => {
    if (err) {
      return res.status(500).send('Logout failed');
    }
    res.send('Logout successful');
  });
});

app.listen(3000, () => {
  console.log('Server is running on http://localhost:3000');
});

注意事项

1. 安全性：

   • Session Fixation：确保在用户登录时创建新的 Session ID，以防止会话固定攻击。
   • CSRF 防护：使用 CSRF 令牌来防止跨站请求伪造攻击。
   • HTTPS：在生产环境中，强烈建议使用 HTTPS 以保护 Cookie 传输的安全。

2. Session 管理：

   • Session 过期：可以设置 Session 的过期时间，以减少被劫持的风险。
   • 服务器端存储：对于大型应用，可以使用数据库或分布式缓存（如 Redis）来管理会话，以提高性能和可扩展性。

SAML Authentication

SAML（Security Assertion Markup Language）是一种用于交换身份验证和授权数据的标准协议，常用于单点登录（Single Sign-On, SSO）系统。SAML 允许用户使用一个身份验证凭据在多个独立的应用程序或服务之间进行安全访问。

SAML 认证的原理

SAML 认证的核心思想是通过身份提供者（Identity Provider, IdP）和服务提供者（Service Provider, SP）之间交换 SAML 断言（Assertion），来实现身份验证和授权。以下是主要的组件和概念：

1. 身份提供者（IdP）：负责验证用户的身份并生成 SAML 断言，断言中包含用户的身份信息和权限信息。

2. 服务提供者（SP）：提供服务的应用程序，接收并验证 SAML 断言，以确定用户的身份和权限。

3. SAML 断言：由 IdP 生成的 XML 格式的消息，包含用户身份的验证信息。

4. 浏览器：用户的浏览器在 IdP 和 SP 之间传递 SAML 消息。

SAML 认证的基本流程

SAML 认证通常遵循以下步骤：

1. 用户访问服务提供者：用户尝试访问 SP 提供的资源或服务。SP 发现用户未登录，因此重定向用户到 IdP。

2. 服务提供者发送 SAML 请求：SP 构造一个 SAML 认证请求，并将用户重定向到 IdP。SAML 请求通常通过用户的浏览器以重定向的方式传递。

3. 身份提供者进行用户身份验证：IdP 接收到 SAML 请求后，要求用户进行身份验证（如输入用户名和密码）。验证成功后，IdP 生成一个 SAML 断言。

4. 身份提供者返回 SAML 响应：IdP 将生成的 SAML 断言封装在 SAML 响应中，并通过用户的浏览器将其重定向回 SP。

5. 服务提供者验证 SAML 响应：SP 接收 SAML 响应后，验证其合法性（包括签名验证、时间戳验证等）。验证成功后，用户即被认为已登录，SP 提供相应的服务或资源。

6. 用户访问服务：用户现在可以访问 SP 提供的资源或服务，而无需再次输入凭据。

SAML 认证的事例代码

以下是一个简单的 SAML 认证的例子，展示了如何使用 Python 实现一个 SAML 服务提供者（SP）。我们将使用 python3-saml 库，这是一个支持 SAML 2.0 协议的 Python 库。

1. 安装依赖库：

   pip install python3-saml
   

2. 配置 SAML 设置： 创建一个 settings.json 文件，用于配置 SAML SP 和 IdP 的相关信息：

   {
     "strict": true,
     "debug": true,
     "sp": {
       "entityId": "http://localhost:8000/metadata/",
       "assertionConsumerService": {
         "url": "http://localhost:8000/acs/",
         "binding": "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST"
       },
       "singleLogoutService": {
         "url": "http://localhost:8000/sls/",
         "binding": "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect"
       },
       "x509cert": "",
       "privateKey": ""
     },
     "idp": {
       "entityId": "https://idp.example.com/metadata",
       "singleSignOnService": {
         "url": "https://idp.example.com/sso",
         "binding": "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect"
       },
       "singleLogoutService": {
         "url": "https://idp.example.com/slo",
         "binding": "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect"
       },
       "x509cert": "MIIC..."
     }
   }
   

3. 创建 SAML 服务提供者（SP）逻辑：

   from onelogin.saml2.auth import OneLogin_Saml2_Auth
   from flask import Flask, request, redirect, session
   
   app = Flask(__name__)
   app.secret_key = 'your_secret_key'
   
   def init_saml_auth(req):
       auth = OneLogin_Saml2_Auth(req, custom_base_path="path/to/saml/folder")
       return auth
   
   def prepare_flask_request(request):
       return {
           'https': 'on' if request.scheme == 'https' else 'off',
           'http_host': request.host,
           'script_name': request.path,
           'server_port': request.host.split(':')[1] if ':' in request.host else '443' if request.scheme == 'https' else '80',
           'get_data': request.args.copy(),
           'post_data': request.form.copy()
       }
   
   @app.route('/sso/', methods=['GET'])
   def sso():
       req = prepare_flask_request(request)
       auth = init_saml_auth(req)
       return redirect(auth.login())
   
   @app.route('/acs/', methods=['POST'])
   def acs():
       req = prepare_flask_request(request)
       auth = init_saml_auth(req)
       auth.process_response()
       errors = auth.get_errors()
       if len(errors) == 0:
           session['samlUserdata'] = auth.get_attributes()
           return redirect('/')
       else:
           return 'Error: ' + ', '.join(errors)
   
   @app.route('/metadata/', methods=['GET'])
   def metadata():
       req = prepare_flask_request(request)
       auth = init_saml_auth(req)
       settings = auth.get_settings()
       metadata = settings.get_sp_metadata()
       errors = settings.validate_metadata(metadata)
       if len(errors) == 0:
           return metadata, 200, {'Content-Type': 'text/xml'}
       else:
           return 'Error: ' + ', '.join(errors)
   
   if __name__ == "__main__":
       app.run(host="0.0.0.0", port=8000)
   

4. 运行 Flask 应用：

   使用以下命令运行 Flask 应用程序：

   python app.py
   

OpenID Authentication

OpenID Connect（OIDC）是一个基于 OAuth 2.0 协议的身份认证协议。它扩展了 OAuth 2.0，使得可以通过一个统一的身份提供者进行用户认证，简化了单点登录（SSO）的实现。OIDC 允许客户端应用程序验证用户的身份，并获取与用户相关的基本信息。

原理

OpenID Connect 主要基于以下几个关键组件：

1. 身份提供者（Identity Provider, IdP）：提供用户身份认证服务的服务器。
2. 客户端（Client）：需要认证用户身份的应用程序。
3. 授权服务器（Authorization Server）：处理认证请求并颁发认证凭证。
4. 用户（User）：需要进行身份认证的个人。

OIDC 扩展了 OAuth 2.0 的访问令牌（Access Token），增加了一个 ID 令牌（ID Token）。ID 令牌用于传递用户身份信息，而访问令牌用于访问受保护的资源。

步骤

1. 用户授权（Authorization Request）：

   • 用户在客户端应用程序上点击登录按钮，客户端应用程序重定向用户到身份提供者的授权端点。
   • 请求包含 response_type=code（表示使用授权码流程）、client_id、redirect_uri 和其他参数。

2. 用户认证（Authentication）：

   • 身份提供者展示登录页面，用户输入凭证进行身份验证。

3. 授权码返回（Authorization Code Response）：

   • 身份提供者验证用户身份后，将用户重定向回客户端应用程序指定的重定向 URI，并附上授权码。

4. 令牌交换（Token Exchange）：

   • 客户端应用程序使用授权码向身份提供者的令牌端点请求访问令牌和 ID 令牌。
   • 请求中包含 grant_type=authorization_code、code、redirect_uri 和 client_secret。

5. 令牌颁发（Token Issuance）：

   • 身份提供者验证授权码后，返回访问令牌和 ID 令牌。

6. ID 令牌验证（ID Token Validation）：

   • 客户端应用程序使用 ID 令牌中的信息验证用户身份，并可能通过访问令牌访问用户的其他信息。

事例代码

以下是一个使用 Node.js 和 openid-client 库进行 OpenID Connect 认证的示例代码：

const { Issuer, Client } = require('openid-client');

// 1. 配置身份提供者
(async () => {
  const issuer = await Issuer.discover('https://accounts.google.com'); // Google OpenID Connect Provider

  // 2. 创建客户端
  const client = new issuer.Client({
    client_id: 'YOUR_CLIENT_ID',
    client_secret: 'YOUR_CLIENT_SECRET',
    redirect_uris: ['http://localhost:3000/callback'],
    response_types: ['code'],
  });

  // 3. 生成授权 URL
  const authorizationUrl = client.authorizationUrl({
    scope: 'openid profile email',
  });

  console.log('Authorization URL:', authorizationUrl);

  // 4. 在用户登录后，通过授权码交换令牌
  const code = 'AUTHORIZATION_CODE_FROM_CALLBACK'; // 需要从重定向 URI 中获取
  const tokenSet = await client.callback('http://localhost:3000/callback', { code });

  console.log('ID Token:', tokenSet.id_token);
  console.log('Access Token:', tokenSet.access_token);

  // 5. 验证 ID 令牌
  const userInfo = await client.userinfo(tokenSet.access_token);
  console.log('User Info:', userInfo);
})();

详细解释

• Issuer.discover(url)：发现并获取身份提供者的配置信息。
• client.authorizationUrl()：生成授权 URL，引导用户进行身份认证。
• client.callback(redirectUri, params)：使用授权码换取访问令牌和 ID 令牌。
• client.userinfo(accessToken)：获取用户信息。