# OAuth2 身份验证使用 OAuth2 和 OpenID Connect 实施安全身份验证和授权的综合技能。该技能涵盖所有主要授权流程、令牌管理策略、安全最佳实践以及 Web、移动和 API 应用程序的实际实施模式。 ## 何时使用此技能在以下情况下使用此技能： * 在 Web 应用程序、SPA 或移动应用程序中实施用户身份验证 * 使用访问令牌和刷新令牌构建 API 授权 * 集成社交登录（Google、GitHub、Facebook、Twitter 等） * 创建安全的机器对机器 (M2M) 身份验证 * 跨多个应用程序实施单点登录 (SSO) * 构建 OAuth2 授权服务器或身份提供者 * 添加委托授权，允许第三方访问 * 使用基于令牌的身份验证来保护 API * 实现无密码身份验证流程 * 添加具有组织特定规则的多租户身份验证 * 从基于会话的身份验证迁移到基于令牌的身份验证 * 使用 OAuth2 范围实施细粒度访问控制 ## 核心概念 ### OAuth2 基础知识 OAuth2 是一个授权框架，使应用程序能够获得对 HTTP 服务上的用户帐户的有限访问权限。它的工作原理是将用户身份验证委托给托管用户帐户的服务，并授权第三方应用程序访问该帐户。 **关键术语：** * **资源所有者** : 拥有数据或资源的用户 * **客户端** ：请求访问资源的应用程序（Web 应用程序、移动应用程序、SPA） * **授权服务器** ：在验证资源所有者身份后发出访问令牌 * **资源服务器**：托管受保护的资源，接受并验证访问令牌 * **访问令牌** ：用于访问受保护资源的短期凭证 * **刷新令牌** ：用于获取新访问令牌的长期凭证 * **范围** ：授予访问特定资源或执行操作的权限 * **授权代码** ：交换访问令牌的临时代码 * **状态参数** ：在授权流程中防止 CSRF 攻击 * **重定向 URI** ：授权后用户重定向的回调 URL ### OAuth2 授权类型（授权流程） OAuth2 为不同的用例定义了几种授权类型： #### 1\.授权码流程 **最安全的流程 - 推荐用于服务器端应用程序** 授权代码流程是最安全且使用最广泛的 OAuth2 流程。它涉及在服务器端用授权代码交换访问令牌。 **流程步骤：** 1. 客户端使用 client_id、redirect_uri、scope 和 state 将用户重定向到授权服务器 2. 用户验证并同意所请求的权限 3. 授权服务器使用授权码重定向回客户端 4. 客户端使用客户端密钥交换访问令牌的代码（服务器端） 5. 客户端使用访问令牌访问受保护的资源 **何时使用：** * 传统的服务器端Web应用程序 * 可以安全存储客户端机密的应用程序 * 当您需要最大程度的安全时 * 当需要刷新令牌时 **安全优势：** * 访问令牌从未暴露给浏览器 * 通过客户端密码进行客户端身份验证 * 授权码是一次性的且短暂的 * 状态参数防止CSRF攻击 #### 2\.使用 PKCE 的授权代码流程 **公共客户的安全流程（SPA 和移动应用程序）** PKCE（代码交换证明密钥，发音为“pixy”）是授权代码流的扩展，专为无法安全存储客户端机密的公共客户端而设计。 **流程步骤：** 1.客户端生成code_verifier（随机字符串）和code_challenge（SHA256哈希） 2.客户端使用code_challenge重定向到授权服务器 3. 用户认证并同意 4.授权服务器返回授权码 5.客户端用code+code_verifier交换访问令牌 6. 服务器验证code_verifier是否匹配code_challenge **何时使用：** * 单页应用程序 (SPA) * 移动应用程序（iOS、Android） * 桌面应用程序 * 任何不能存储秘密的公共客户端 **安全优势：** * 防止授权码拦截攻击 * 无需客户端密码 * 防止恶意应用拦截重定向 * OAuth2 安全最佳实践推荐 (RFC 8252) #### 3\.客户端凭证流程 **机器对机器身份验证** 当客户端本身是资源所有者时，将使用客户端凭证流，通常用于服务到服务的通信。 **流程步骤：** 1. 客户端使用client_id和client_secret进行身份验证 2. 授权服务器验证凭证 3. 授权服务器颁发访问令牌 4.客户端使用token访问受保护的资源 **何时使用：** * 与API通信的后端服务 * Cron 作业或计划任务 * 微服务认证 * CI/CD 管道访问 API * 无需用户上下文的系统级操作 **特点：** * 无需用户参与 * 客户端是资源所有者 * 没有刷新令牌（只需请求新的访问令牌） * 通常是长期存在或缓存的令牌 #### 4\.隐式流（已弃用） **旧版流程 - 不再推荐** 隐式流程直接在 URL 片段中返回令牌，无需授权代码交换。这种流程现在被认为是不安全的，应该避免。 **为什么弃用：** * 浏览器历史记录中公开的访问令牌 * 无需客户端验证 * 不支持刷新令牌 * 容易遭受代币盗窃 * 使用带有 PKCE 的授权代码流程 #### 5\.资源所有者密码凭证 (ROPC) **遗留流程 - 除非必要，否则避免** 资源所有者密码凭证流程允许客户端直接收集用户名和密码，然后将它们交换为令牌。 **流程步骤：** 1. 用户向客户端提供用户名和密码 2. 客户端将凭据发送到授权服务器 3. 授权服务器验证并颁发token **何时使用（很少）：** * 从传统身份验证迁移的第一方移动应用程序 * 仅限受信任的第一方应用程序 * 当没有浏览器/重定向流可用时 **为什么要避免：** * 客户端直接处理用户凭证（安全风险） * 不支持多重身份验证 * 网络钓鱼漏洞 * 违反OAuth2委托授权原则 * 尽可能使用带有 PKCE 的授权代码流 #### 6\。设备授权流程 **对于输入受限的设备** 该设备流程专为输入功能有限的设备（智能电视、物联网设备、CLI 工具）而设计。 **流程步骤：** 1.设备向授权服务器请求设备码和用户码 2.设备显示用户代码并指示用户访问URL 3. 用户在另一台设备上访问 URL 并输入用户代码 4. 用户对设备进行认证和授权 5. 设备轮询授权服务器以获取访问令牌 6. 用户完成授权后，授权服务器颁发访问令牌 **何时使用：** * 智能电视和流媒体设备 * 没有键盘的物联网设备 * CLI 工具和命令行应用程序 * 游戏机 * 任何打字困难的设备 ### 代币类型和管理 #### 访问令牌 **用于访问受保护资源的短期凭证** **特点：** * 通常会在 15 分钟到 1 小时内过期 * 不记名令牌格式：`授权：不记名 ` * 可以是不透明令牌或 JWT（JSON Web 令牌） * 应被视为敏感凭证 * 切勿在 URL 中记录或公开 * 验证每个 API 请求 **JWT 结构（使用 JWT 时）：** 标头.有效负载.签名 **JWT 有效负载声明：** * `sub`: 主题（用户 ID） * `iat`: 发布时间 * `exp`: 过期时间 * `iss`: 发行者（授权服务器） * `aud`: 受众（资源服务器） * `scope`: 授予的权限 * 自定义声明（用户元数据、角色等） **令牌验证：** * 使用公钥验证签名 * 检查到期时间（exp 索赔） * 验证发行人（iss 声明） * 验证受众（aud 声明） * 检查令牌是否具有所需的范围 #### 刷新令牌 **用于获取新访问令牌的长期凭据** **特点：** * 通常在几天、几周或几个月内到期 * 一次性或可重复使用（取决于实施方式） * 必须安全存储（切勿存储在浏览器的 localStorage 中） * 应在静态时加密 * 可以被授权服务器撤销 * 遵守轮换政策 **刷新令牌轮换：** * 每次刷新都会发出一个新的刷新令牌 * 旧的刷新令牌失效 * 防止令牌重放攻击 * 检测令牌盗窃（多次刷新尝试） * 推荐的安全实践 **令牌存储最佳实践：** **网络应用程序：** * 访问令牌：内存（React context、Vuex、Redux） * 刷新令牌：HttpOnly、Secure、SameSite cookies *替代方案：在后端存储刷新令牌，使用会话 **移动应用程序：** * 使用平台安全存储 * iOS：钥匙串服务 * Android：EncryptedSharedPreferences 或密钥库 * 切勿存储在纯文本文件中 **SPA：** * 仅将访问令牌存储在内存中 * 使用 BFF（前端后端）模式来刷新令牌 * 考虑令牌处理程序模式 * 避免localStorage（XSS漏洞） #### ID 令牌（OpenID Connect） **包含用户身份信息的令牌** **特点：** * 始终为 JWT 格式 * 包含用户个人资料信息 * 用于身份验证（不是授权） * 与访问令牌一起返回 * 使用前应进行验证 **标准声明：** * `sub`: 主题（唯一用户 ID） * `name`: 全名 * `电子邮件`: 电子邮件地址 * `email_verified`: 电子邮件验证状态 * `图片`: 个人资料图片网址 * `iat`, `exp`: 发布/过期时间 ### OAuth2 范围 **细粒度的访问控制权限** 范围定义客户端请求的访问权限以及访问令牌允许的访问权限。 **范围命名约定：** * `read:users` \- 读取用户数据 * `write:users` \- 创建/更新用户 * `delete:users` \- 删除用户 * `admin:all` \- 完全管理访问权限 * `openid` \- 请求 OpenID Connect ID 令牌 * `profile` \- 访问用户个人资料信息 * `email` \- 访问用户电子邮件地址 **最佳实践：** * 请求所需的最小范围（最小权限原则） * 读写权限分开 * 创建特定于资源的范围 * 记录所有可用范围 * 允许用户查看并理解请求的权限 * 在API中实现基于范围的访问控制 **动态范围：** 阅读：组织：{org_id} 写：项目：{project_id} 管理员：租户：{tenant_id} ### 安全考虑 #### 状态参数 **防止跨站请求伪造 (CSRF)** 状态参数是客户端包含在授权请求中并在回调中验证的随机值。 **实施：** 1. 生成随机状态值（加密安全） 2. 将状态存储在会话或加密的cookie中 3. 在授权 URL 中包含状态 4. 接收回调时验证状态匹配 5. 拒绝不匹配或缺失的状态 **状态值示例：** 状态： crypto.randomBytes(32).toString('hex') //“7f8a3d9e2b1c4f5a6d8e9f0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0” #### PKCE 实施 **代码交换的证明密钥 - 防止代码拦截** PKCE 保护授权代码流免受授权代码拦截攻击。 **代码验证器：** * 随机字符串，43-128个字符 * 字符：A-Z、a-z、0-9、-、.、_、~ * 安全地存储在客户端 **代码挑战：** * 代码验证器的SHA256哈希值（推荐） * 或明码验证器（不推荐） * 在授权请求中发送 **代码挑战方法：** * `S256`: SHA256 哈希（使用这个） * `plain`：明文验证器（仅限旧版本） **实施示例：** // 生成验证码 const codeVerifier =generateRandomString(64); // 生成代码挑战 const codeChallenge = base64UrlEncode( sha256（代码验证器））； // 存储用于令牌交换的验证码 sessionStorage.setItem('code_verifier', codeVerifier); // 包含在授权 URL 中 const authUrl = `${authEndpoint}?` + `client_id=${clientId}` + `&redirect_uri=${redirectUri}` + `&response_type=代码` + `&scope=${范围}` + `&state=${state}` + `&code_challenge=${codeChallenge}` + `&code_challenge_method=S256`; #### 令牌安全 **保护访问和刷新令牌** **做：** * 对所有 OAuth2 端点使用 HTTPS * 仅将刷新令牌存储在安全存储中 * 实施代币轮换 * 设置适当的令牌过期时间 * 验证每个 API 请求的令牌 * 使用具有强大签名算法的 JWT（RS256、ES256） * 实现令牌撤销 * 监控可疑的令牌使用情况 **不要：** * 将令牌存储在localStorage中（XSS风险） * 在 URL 或查询参数中包含令牌 * 在应用程序日志中记录令牌 * 使用弱签名算法（具有共享秘密的 HS256） * 在应用程序之间共享代币 * 不必要地延长访问令牌的生命周期 * 忽略令牌过期 #### 重定向 URI 验证 **防止开放重定向漏洞** **严格的验证规则：** * 需要精确匹配（无通配符） * 协议必须完全匹配 (https://) * 主机必须完全匹配 * 端口必须匹配（如果指定） * 路径必须匹配（如果指定） * 提前注册所有重定向URI **移动深层链接：** * 使用自定义 URL 方案：`com.example.app://callback` * 或通用链接 (iOS)：`https://example.com/auth/callback` * 或应用程序链接 (Android)：`https://example.com/auth/callback` * 向授权服务器注册方案 **本地主机开发：** * 只允许用于开发 * 指定确切的端口：`http://localhost:3000/callback` * 如果 localhost 不起作用，请使用 127.0.0.1 * 切勿在生产中使用本地主机重定向 ### OpenID 连接 (OIDC) **基于 OAuth2 的身份层** OpenID Connect 在 OAuth2 之上添加了一个身份层，除了授权之外还提供身份验证。 **与 OAuth2 的主要区别：** * 除了访问令牌之外还返回 ID 令牌 * ID token包含用户身份信息 * 标准化的用户信息端点 *标准化发现端点（.wellknown/openid-configuration） * 会话管理功能 **OIDC 流量：** 1. **授权码流程**（推荐） * 与OAuth2相同但返回id_token * 对于网络应用程序来说最安全 2. **隐式流**（已弃用） * 直接返回id_token * 不安全，请使用带有 PKCE 的代码流 3. **混合流** * 结合代码和隐式流程 * 复杂，很少需要 **OIDC 范围：** * `openid`（必需）- 启用 OIDC * `profile` \- 名称、图片、区域设置等。 * `email` \- 电子邮件地址和验证状态 * `address` \- 物理地址 * `phone` \- 电话号码 **用户信息端点：** 获取/用户信息授权：持有者回应： { “子”：“248289761001”， “姓名”：“简·多伊”， “电子邮件”：“jane@example.com”， “email_verified”：正确， “图片”：“https://example.com/photo.jpg” } **ID令牌验证：** 1. 使用提供商的公钥验证签名 2. 验证发行人（iss 声明） 3. 验证受众（aud 声明 - 应与 client_id 匹配） 4.检查有效期（exp Claim） 5. 验证随机数（如果请求中提供） 6.最近发行了支票令牌（iat 索赔） ### 多租户模式 **组织特定的身份验证** 许多 SaaS 应用程序要求用户在组织或租户的上下文中进行身份验证。 **图案：** 1. **组织参数** * 在授权请求中包含组织 ID * `scope=openid 配置文件组织：acme-corp` * 代币适用于特定组织 2. **组织选择器** * 用户在初次认证后选择组织 * 将代币兑换为组织特定的代币 * 支持切换组织 3. **每个租户的自定义域** * `acme.example.com` 与 `globex.example.com` * 每个租户单独的 OAuth2 配置 * 白标认证体验 4. **代币索赔的组织** * 在访问令牌中包含 org_id * API验证组织访问权限 * 支持多个组织的用户 ## 授权码流程实现 ### 服务器端 Web 应用程序流程 **带后端的传统 Web 应用程序的完整实现** #### 第 1 步：配置 // OAuth2 配置常量 oauth2Config = { clientId：process.env.OAUTH2_CLIENT_ID， clientSecret：process.env.OAUTH2_CLIENT_SECRET，授权端点：'https://auth.example.com/oauth/authorize'， tokenEndpoint: 'https://auth.example.com/oauth/token', redirectUri: 'https://yourapp.com/auth/callback', 范围：['openid'、'个人资料'、'电子邮件'、'读取：数据']、 // 可选的 OIDC 端点 userInfoEndpoint: 'https://auth.example.com/oauth/userinfo', jwksUri: 'https://auth.example.com/.well-known/jwks.json', // 安全设置 useState参数: true, usePKCE: false, // 机密客户端不需要 }; #### 第 2 步：生成授权 URL const crypto = require('crypto'); 函数generateAuthorizationUrl(req) { // 生成并存储 CSRF 保护状态 const state = crypto.randomBytes(32).toString('hex'); req.session.oauth2State = 状态； // 构建授权URL const params = new URLSearchParams({ client_id：oauth2Config.clientId， redirect_uri：oauth2Config.redirectUri，响应类型：'代码'，范围： oauth2Config.scopes.join(' '), 状态：状态， }); 返回 `${oauth2Config.authorizationEndpoint}?${params.toString()}`; } // Express.js 路线 app.get('/auth/login', (req, res) => { const authUrl =generateAuthorizationUrl(req); res.redirect(authUrl); }); #### 步骤 3：处理回调和交换代码 const axios = require('axios'); 异步函数 ExchangeCodeForToken(code) { const 响应 = 等待 axios.post( oauth2Config.tokenEndpoint，新的 URLSearchParams({ grant_type: '授权码', 代码：代码， redirect_uri：oauth2Config.redirectUri， client_id：oauth2Config.clientId， client_secret：oauth2Config.clientSecret， }), { 标题：{ '内容类型': 'application/x-www-form-urlencoded', }, } ）；返回响应数据； // 返回：{ access_token、refresh_token、token_type、expires_in、id_token } } // 回调路由 app.get('/auth/callback', async (req, res) => { const { 代码、状态、错误、error_description } = req.query; // 检查授权错误如果（错误）{ console.error('授权错误：', error, error_description); return res.redirect('/auth/error?message=' + error_description); } // 验证状态参数（CSRF保护） if (state !== req.session.oauth2State) { console.error('状态不匹配 - 可能的 CSRF 攻击'); return res.status(403).send('状态参数无效'); } // 清除会话状态删除req.session.oauth2State；尝试{ // 用授权码换取token const tokens =等待exchangeCodeForToken(code); // 将令牌安全地存储在会话中 req.session.accessToken = tokens.access_token; req.session.refreshToken = tokens.refresh_token; req.session.tokenExpiry = Date.now() + (tokens.expires_in * 1000); // 可选：获取用户信息 if (tokens.id_token) { const userInfo =等待 getUserInfo(tokens.access_token); req.session.user = userInfo; } // 重定向到应用程序 res.redirect('/仪表板'); } 捕获（错误）{ console.error('令牌交换失败：', error); res.redirect('/auth/error?message=身份验证失败'); } }); #### 步骤 4：使用访问令牌进行 API 请求 // 检查身份验证的中间件函数 requireAuth(req, res, next) { if (!req.session.accessToken) { return res.redirect('/auth/login'); } // 检查token是否过期 if (Date.now() > req.session.tokenExpiry) { // Token过期，尝试刷新返回refreshAccessToken(req, res, next); } 下一个（）; } // 带有访问令牌的 API 请求异步函数 fetchUserData(accessToken) { const 响应 = 等待 axios.get('https://api.example.com/user/data', { 标题：{ '授权': `承载${accessToken}`, }, }); 返回响应数据； } // 受保护的路由 app.get('/dashboard', requireAuth, async (req, res) => { 尝试{ const userData =等待 fetchUserData(req.session.accessToken); res.render('dashboard', { user: req.session.user, data: userData }); } 捕获（错误）{ console.error('API请求失败:', error); res.status(500).send('获取数据失败'); } }); #### 步骤 5：实施令牌刷新异步函数refreshAccessToken(req, res, next) { if (!req.session.refreshToken) { // 无刷新令牌，需要重新认证 return res.redirect('/auth/login'); } 尝试{ const 响应 = 等待 axios.post( oauth2Config.tokenEndpoint，新的 URLSearchParams({ grant_type: 'refresh_token', 刷新令牌：req.session.refreshToken， client_id：oauth2Config.clientId， client_secret：oauth2Config.clientSecret， }), { 标题：{ '内容类型': 'application/x-www-form-urlencoded', }, } ）； // 更新会话中的令牌 req.session.accessToken = response.data.access_token; req.session.tokenExpiry = Date.now() + (response.data.expires_in * 1000); // 如果启用了旋转，则更新刷新令牌 if (response.data.refresh_token) { req.session.refreshToken = response.data.refresh_token; } 下一个（）; } 捕获（错误）{ console.error('令牌刷新失败：', error); // 刷新失败，需要重新认证删除req.session.accessToken；删除req.session.refreshToken； res.redirect('/auth/login'); } } #### 第 6 步：实施注销 app.post('/auth/logout', async (req, res) => { // 可选：撤销授权服务器上的令牌 if (req.session.accessToken) { 尝试{ 等待 revokeToken(req.session.accessToken); } 捕获（错误）{ console.error('令牌撤销失败:', error); } } // 清除会话 req.session.destroy((err) => { 如果（错误）{ console.error('会话销毁失败:', err); } res.redirect('/'); }); }); 异步函数 revokeToken(token) { 等待 axios.post( 'https://auth.example.com/oauth/revoke', 新的 URLSearchParams({ 令牌：令牌， client_id：oauth2Config.clientId， client_secret：oauth2Config.clientSecret， }), { 标题：{ '内容类型': 'application/x-www-form-urlencoded', }, } ）； } ## PKCE 实施（SPA 和移动应用程序） ### 单页应用程序（React） **使用 React SPA 的 PKCE 实现完成 OAuth2** #### 设置和配置 // src/config/oauth2.js 导出常量 oauth2Config = { clientId：process.env.REACT_APP_OAUTH2_CLIENT_ID，授权端点：'https://auth.example.com/oauth/authorize'， tokenEndpoint: 'https://auth.example.com/oauth/token', redirectUri: window.location.origin + '/auth/callback', 范围：['openid'、'个人资料'、'电子邮件'、'读取：数据']、受众：'https://api.example.com'， }; // PKCE 实用函数导出函数generateRandomString(length) { const 字符集 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~'; const 值 = crypto.getRandomValues(new Uint8Array(length)); 返回 Array.from(值) .map(v => 字符集[v % 字符集.长度]) .join(''); } 导出异步函数generateCodeChallenge(codeVerifier) { const 编码器 = new TextEncoder(); const data = 编码器.encode(codeVerifier); const 摘要=等待 crypto.subtle.digest('SHA-256', data); 返回base64UrlEncode（摘要）； } 导出函数base64UrlEncode（缓冲区）{ const 字节 = new Uint8Array(buffer); 让二进制=''； for (让 i = 0; i < bytes.byteLength; i++) { 二进制 += String.fromCharCode(bytes[i]); } 返回 btoa（二进制） .replace(/\+/g, '-') .replace(/\//g, '_') .replace(/=/g, ''); } #### 身份验证上下文提供者 // src/contexts/AuthContext.js 导入 React, { createContext, useState, useContext, useEffect } from 'react'; 从'../config/oauth2'导入{oauth2Config，generateRandomString，generateCodeChallenge}； const AuthContext = createContext(); 导出函数 useAuth() { 返回 useContext(AuthContext); } 导出函数 AuthProvider({ 孩子 }) { const [用户，setUser] = useState(null); const [accessToken, setAccessToken] = useState(null); const [正在加载，setLoading] = useState(true); 使用效果（（）=> { // 检查现有会话检查验证（）； }, []); 异步函数 checkAuth() { // 尝试从内存中恢复访问令牌或刷新 const storeToken = sessionStorage.getItem('access_token'); const expiresAt = sessionStorage.getItem('expires_at'); if (storedToken && expiresAt && Date.now() < parseInt(expiresAt)) { setAccessToken(storedToken); 等待 fetchUserInfo(storedToken); } 否则{ // Token过期或者不存在，尝试刷新等待尝试刷新（）； } 设置加载（假）； } 异步函数登录() { // 生成PKCE参数 const codeVerifier =generateRandomString(64); const codeChallenge =等待generateCodeChallenge(codeVerifier); 常量状态=generateRandomString(32); // 存储回调 sessionStorage.setItem('code_verifier', codeVerifier); sessionStorage.setItem('oauth2_state', 状态); // 构建授权URL const params = new URLSearchParams({ client_id：oauth2Config.clientId， redirect_uri：oauth2Config.redirectUri，响应类型：'代码'，范围： oauth2Config.scopes.join(' '), 状态：状态， code_challenge：代码挑战， code_challenge_method: 'S256', }); // 重定向到授权服务器 window.location.href = `${oauth2Config.authorizationEndpoint}?${params}`; } 异步函数handleCallback（代码，状态）{ // 验证状态 const saveState = sessionStorage.getItem('oauth2_state'); if (状态!==保存状态) { throw new Error('无效的状态参数 - 可能的 CSRF 攻击'); } // 获取验证码 const codeVerifier = sessionStorage.getItem('code_verifier'); 如果（！codeVerifier）{ throw new Error('未找到代码验证器'); } // 兑换代币代码 const 响应 = 等待 fetch(oauth2Config.tokenEndpoint, { 方法：'POST'，标题：{ '内容类型': 'application/x-www-form-urlencoded', }, 正文：新的 URLSearchParams({ grant_type: '授权码', 代码：代码， redirect_uri：oauth2Config.redirectUri， client_id：oauth2Config.clientId， code_verifier：代码验证器， }), }); 如果（！response.ok）{ throw new Error('代币交换失败'); } const tokens =等待response.json(); // 存储令牌 setAccessToken(tokens.access_token); sessionStorage.setItem('access_token', tokens.access_token); sessionStorage.setItem('expires_at', Date.now() + (tokens.expires_in * 1000)); // 通过后端将刷新令牌存储在 httpOnly cookie 中 if (tokens.refresh_token) { 等待 storeRefreshToken(tokens.refresh_token); } // 获取用户信息等待 fetchUserInfo(tokens.access_token); // 清理 sessionStorage.removeItem('code_verifier'); sessionStorage.removeItem('oauth2_state'); } 异步函数 fetchUserInfo(token) { const 响应 = 等待 fetch('https://auth.example.com/oauth/userinfo', { 标题：{ '授权': `不记名${token}`, }, }); 如果（响应.ok）{ const userInfo = 等待response.json(); setUser(用户信息); } } 异步函数 storeRefreshToken(refreshToken) { // 通过后端存储刷新令牌（httpOnly cookie）等待 fetch('/api/auth/store-refresh-token', { 方法：'POST'，凭据：“包括”，标题：{ '内容类型'：'应用程序/json'， }, 主体：JSON.stringify（{refreshToken}）， }); } 异步函数 tryRefresh() { 尝试{ // 调用后端使用httpOnly cookie进行刷新 const 响应 = 等待 fetch('/api/auth/refresh', { 方法：'POST'，凭据：“包括”， }); 如果（响应.ok）{ const tokens =等待response.json(); setAccessToken(tokens.access_token); sessionStorage.setItem('access_token', tokens.access_token); sessionStorage.setItem('expires_at', Date.now() + (tokens.expires_in * 1000)); 等待 fetchUserInfo(tokens.access_token); 返回真； } } 捕获（错误）{ console.error('令牌刷新失败：', error); } 返回假； } 异步函数注销() { // 撤销令牌等待 fetch('/api/auth/logout', { 方法：'POST'，凭据：“包括”， }); // 清除状态 setUser(空); setAccessToken(空); sessionStorage.clear(); } 常量值 = { 用户，访问令牌，正在加载，登录，注销，处理回调， isAuthenticated: !!accessToken, }; 返回 {children}; } #### 回调组件 // src/components/AuthCallback.js 从 'react' 导入 React, { useEffect, useState }; 从 'react-router-dom' 导入 { useNavigate, useSearchParams }; 从 '../contexts/AuthContext' 导入 { useAuth } ；导出函数 AuthCallback() { const [searchParams] = useSearchParams(); 常量导航 = useNavigate(); const { handleCallback } = useAuth(); const [错误，setError] = useState(null); 使用效果（（）=> { const code = searchParams.get('code'); const state = searchParams.get('state'); const errorParam = searchParams.get('错误'); const errorDescription = searchParams.get('error_description'); if (错误参数) { setError(错误描述 || 错误参数); 返回； } if（代码&&状态）{ 处理回调（代码，状态） .then(() => { 导航（'/仪表板'）； }) .catch((错误) => { console.error('身份验证失败：', err); setError(err.message); }); } 否则{ setError('缺少授权码或状态'); } }，[searchParams，handleCallback，导航]）；如果（错误）{ 返回（

身份验证失败

{错误}

）； } 返回（

正在完成身份验证...

）； } #### 受保护的路由组件 // src/components/ProtectedRoute.js 从“反应”导入反应；从'react-router-dom'导入{导航}；从 '../contexts/AuthContext' 导入 { useAuth } ；导出函数 ProtectedRoute({ 儿童 }) { const { isAuthenticated, 加载 } = useAuth(); 如果（加载）{ 返回

正在加载...

; } if (!isAuthenticated) { 返回<导航到=“/登录”/>； } 返回儿童； } #### 具有令牌管理功能的 API 客户端 // src/utils/apiClient.js 从 '../config/oauth2' 导入 { oauth2Config }；类 ApiClient { 构造函数（）{ this.baseUrl = 'https://api.example.com'; } 异步请求（端点，选项= {}）{ const accessToken = sessionStorage.getItem('access_token'); const expiresAt = sessionStorage.getItem('expires_at'); // 检查token是否需要刷新 if (!accessToken || Date.now() >= parseInt(expiresAt)) { 等待 this.refreshToken(); } const token = sessionStorage.getItem('access_token'); const 响应 =等待 fetch(`${this.baseUrl}${endpoint}`, { ...选项，标题：{ ...选项.标题， '授权': `不记名${token}`, '内容类型'：'应用程序/json'， }, }); if (response.status === 401) { // Token无效，尝试刷新一次等待 this.refreshToken(); const newToken = sessionStorage.getItem('access_token'); // 重试请求 const retryResponse = wait fetch(`${this.baseUrl}${endpoint}`, { ...选项，标题：{ ...选项.标题， '授权': `不记名 ${newToken}`, '内容类型'：'应用程序/json'， }, }); 如果（！retryResponse.ok）{ throw new Error('令牌刷新后 API 请求失败'); } 返回 retryResponse.json(); } 如果（！response.ok）{ 抛出新的错误（`API错误：$ {response.status}`）； } 返回response.json(); } 异步刷新令牌() { const 响应 = 等待 fetch('/api/auth/refresh', { 方法：'POST'，凭据：“包括”， }); 如果（！response.ok）{ // 刷新失败，重定向到登录 window.location.href = '/登录'; throw new Error('令牌刷新失败'); } const tokens =等待response.json(); sessionStorage.setItem('access_token', tokens.access_token); sessionStorage.setItem('expires_at', Date.now() + (tokens.expires_in * 1000)); } 异步获取（端点）{ 返回 this.request(端点); } 异步发布（端点，数据）{ 返回 this.request(端点, { 方法：'POST'，正文：JSON.stringify（数据）， }); } 异步放置（端点，数据）{ 返回 this.request(端点, { 方法：'放置'，正文：JSON.stringify（数据）， }); } 异步删除（端点）{ 返回 this.request(端点, { 方法：'删除'， }); } } 导出 const apiClient = new ApiClient(); ## 客户端凭证流程 ### 后端服务认证 **服务和 API 的机器对机器身份验证** #### Node.js 实现 // 服务到服务的身份验证类 OAuth2Client { 构造函数（配置）{ this.clientId = config.clientId; this.clientSecret = config.clientSecret; this.tokenEndpoint = config.tokenEndpoint; this.audience = config.audience; this.scopes = config.scopes || []； this.accessToken = null; this.tokenExpiry = null; } 异步 getAccessToken() { // 如果仍然有效，则返回缓存的令牌 if (this.accessToken && Date.now() < this.tokenExpiry - 60000) { 返回 this.accessToken; } // 请求新的令牌 const 响应 = 等待 fetch(this.tokenEndpoint, { 方法：'POST'，标题：{ '内容类型': 'application/x-www-form-urlencoded', }, 正文：新的 URLSearchParams({ grant_type: 'client_credentials', client_id: this.clientId, client_secret: this.clientSecret, 观众：this.audience，范围： this.scopes.join(' '), }), }); 如果（！response.ok）{ throw new Error('获取访问令牌失败'); } const data =等待response.json(); // 缓存令牌 this.accessToken = data.access_token; this.tokenExpiry = Date.now() + (data.expires_in * 1000); 返回 this.accessToken; } 异步 callApi(端点, 选项 = {}) { const token =等待this.getAccessToken(); const 响应 = 等待获取（端点，{ ...选项，标题：{ ...选项.标题， '授权': `不记名${token}`, }, }); if (response.status === 401) { // Token可能无效，强制刷新重试 this.accessToken = null; const newToken = 等待 this.getAccessToken(); const retryResponse = 等待获取（端点，{ ...选项，标题：{ ...选项.标题， '授权': `不记名 ${newToken}`, }, }); 返回重试响应； } 返回响应； } } // 用法常量 oauth2Client = 新 OAuth2Client({ clientId: process.env.CLIENT_ID, clientSecret：process.env.CLIENT_SECRET， tokenEndpoint: 'https://auth.example.com/oauth/token', 受众：'https://api.example.com'，范围：['读：数据'，'写：数据']， }); // 进行API调用异步函数 fetchData() { const 响应 = 等待 oauth2Client.callApi('https://api.example.com/data'); 返回response.json(); } #### Python 实现 # client_credentials_oauth2.py 导入请求导入时间从日期时间导入日期时间，时间增量 OAuth2Client 类： def __init__(self、client_id、client_secret、token_endpoint、audience=None、scopes=None): self.client_id = client_id self.client_secret = client_secret self.token_endpoint = token_endpoint self.audience = 观众 self.scopes = 范围或 [] self.access_token = 无 self.token_expiry = 无 def get_access_token(self): """获取缓存的令牌或请求新的令牌""" # 如果有效则返回缓存的令牌如果 self.access_token 和 datetime.now() < self.token_expiry - timedelta(分钟=1): 返回 self.access_token # 请求新的令牌数据 = { 'grant_type': 'client_credentials', 'client_id': self.client_id, 'client_secret': self.client_secret, } 如果是自我观众：数据['观众'] = self.观众如果 self.scopes： data['scope'] = ' '.join(self.scopes) 响应 = requests.post( self.token_endpoint，数据=数据， headers={'Content-Type': 'application/x-www-form-urlencoded'} ）如果没有响应。确定：引发异常（f'无法获取访问令牌：{response.text}'） token_data = 响应.json() # 缓存令牌 self.access_token = token_data['access_token'] self.token_expiry = datetime.now() + timedelta(秒=token_data['expires_in']) 返回 self.access_token def call_api(self, url, method='GET', **kwargs): """发出经过身份验证的 API 请求""" 令牌 = self.get_access_token() headers = kwargs.pop('headers', {}) headers['授权'] = f'承载{令牌}' 响应 = requests.request(方法, url, headers=headers, **kwargs) # 处理令牌过期如果响应.status_code == 401： # 强制刷新令牌并重试 self.access_token = 无令牌 = self.get_access_token() headers['授权'] = f'承载{令牌}' 响应 = requests.request(方法, url, headers=headers, **kwargs) 返回响应 # 用法客户端 = OAuth2Client( client_id='your_client_id', client_secret='your_client_secret', token_endpoint='https://auth.example.com/oauth/token', 受众='https://api.example.com', 范围=['读：数据'，'写：数据'] ） # 发出API请求响应 = client.call_api('https://api.example.com/data') 数据 = 响应.json() ## OpenID Connect 实施 ### 完整的 OIDC 集成 **通过身份验证进行身份验证** #### ID 令牌验证 // id-token-validator.js const jwt = require('jsonwebtoken'); const jwksClient = require('jwks-rsa'); 类 IDTokenValidator { 构造函数（配置）{ this.issuer = config.issuer; this.audience = config.audience; this.jwksUri = config.jwksUri; // 用于获取公钥的 JWKS 客户端 this.client = jwksClient({ jwksUri：这个.jwksUri，缓存：真， cacheMaxAge: 86400000, // 24 小时 }); } 异步 getSigningKey(孩子) { const key = 等待 this.client.getSigningKey(kid); 返回 key.getPublicKey(); } 异步验证（idToken）{ 尝试{ // 解码token header得到key ID const 解码 = jwt.decode(idToken, { 完整: true }); 如果（！解码）{ throw new Error('无效的令牌格式'); } // 获取公钥 const publicKey =等待this.getSigningKey(decoded.header.kid); // 验证并解码令牌 const 有效负载 = jwt.verify(idToken, publicKey, { 发行人：this.发行人，观众：this.audience，算法：['RS256'，'ES256']， }); // 附加验证 this.validateClaims(有效负载); 返回有效负载； } 捕获（错误）{ throw new Error(`ID 令牌验证失败：${error.message}`); } } validateClaims（有效负载）{ // 检查所需的声明如果（！payload.sub）{ 抛出新错误（'缺少子声明'）； } if (!payload.iat || !payload.exp) { throw new Error('缺少 iat 或 exp 声明'); } // 检查令牌是否过期（已由 jwt.verify 检查，但请仔细检查） const now = Math.floor(Date.now() / 1000); if (payload.exp < now) { 抛出新错误（'令牌已过期'）； } // 检查令牌将来不会发出 if (payload.iat > now + 60) { throw new Error('未来发行的代币'); } // 可选：检查随机数（如果提供） // if (payload.nonce && Payload.nonce !== ExpectedNonce) { // 抛出 new Error('Nonce 不匹配'); // } 返回真； } } // 用法 const 验证器 = new IDTokenValidator({ 发行者：'https://auth.example.com'，受众：'your_client_id'， jwksUri: 'https://auth.example.com/.well-known/jwks.json', }); 异步函数 validateIDToken(idToken) { 尝试{ const 有效负载 = 等待 validator.validate(idToken); console.log('用户ID：', Payload.sub); console.log('电子邮件：', Payload.email); console.log('名称：', Payload.name); 返回有效负载； } 捕获（错误）{ console.error('ID 令牌验证失败:', error); 抛出错误； } } #### 用户信息端点集成 // 用户信息-client.js 类 UserInfoClient { 构造函数（userInfoEndpoint）{ this.endpoint = userInfoEndpoint; } 异步 getUserInfo(accessToken) { const 响应 = 等待 fetch(this.endpoint, { 标题：{ '授权': `承载${accessToken}`, '接受': '应用程序/json', }, }); 如果（！response.ok）{ throw new Error(`UserInfo 请求失败：${response.status}`); } 返回response.json(); } 异步 getUserInfoWithValidation(accessToken, idTokenPayload) { const userInfo = 等待 this.getUserInfo(accessToken); // 验证 sub 是否与 ID 令牌匹配 if (userInfo.sub !== idTokenPayload.sub) { throw new Error('UserInfo sub 与 ID token sub 不匹配'); } 返回用户信息； } } // 用法 const userInfoClient = new UserInfoClient('https://auth.example.com/oauth/userinfo'); 异步函数 getCompleteUserProfile(accessToken, idToken, 验证器) { // 验证ID令牌 const idTokenPayload = 等待 validator.validate(idToken); // 获取额外的用户信息 const userInfo = 等待 userInfoClient.getUserInfoWithValidation(accessToken, idTokenPayload); // 合并信息返回{ 用户ID：userInfo.sub，电子邮件：userInfo.email，电子邮件验证：userInfo.email_verified，名称：用户信息.名称，给定名称：userInfo.给定名称， familyName: userInfo.family_name, 图片：用户信息.图片，区域设置：userInfo.locale， // 任何自定义声明 ...用户信息， }; } ## 代币管理最佳实践 ### 安全令牌存储 #### 浏览器存储比较 // Web应用程序的令牌存储策略 // ❌ 不好：localStorage（容易受到 XSS 攻击） localStorage.setItem('access_token', token); // 不要这样做 // ❌ 不好：sessionStorage（也容易受到 XSS 攻击） sessionStorage.setItem('access_token', token); // 不要这样做 // ✅ 好：内存中存储（页面刷新时清除）类 TokenStore { 构造函数（）{ this.accessToken = null; this.refreshToken = null; } setTokens（accessToken，refreshToken）{ this.accessToken = accessToken; // 通过后端刷新存储在 httpOnly cookie 中的令牌 // this.refreshToken =刷新令牌; // 不存储在内存中 } 获取访问令牌() { 返回 this.accessToken; } 清除（）{ this.accessToken = null; this.refreshToken = null; } } // ✅ 最佳：后端用于前端 (BFF) 模式 // - 所有令牌存储在后端 // - 会话 cookie 识别用户 // - 没有令牌暴露给浏览器 #### 移动令牌存储（React Native） // React Native 的安全令牌存储从“expo-secure-store”导入*作为SecureStore； // 或 // 从 'react-native-encrypted-storage' 导入 EncryptedStorage; 类 MobileTokenStore { 异步 saveTokens（accessToken，refreshToken）{ 尝试{ 等待 SecureStore.setItemAsync('access_token', accessToken); await SecureStore.setItemAsync('refresh_token', refreshToken); 等待 SecureStore.setItemAsync('token_expiry', Date.now().toString()); } 捕获（错误）{ console.error('无法存储令牌：', error); 抛出错误； } } 异步 getAccessToken() { 尝试{ 返回等待 SecureStore.getItemAsync('access_token'); } 捕获（错误）{ console.error('无法检索访问令牌：', error); 返回空值； } } async getRefreshToken() { 尝试{ 返回等待 SecureStore.getItemAsync('refresh_token'); } 捕获（错误）{ console.error('无法检索刷新令牌：', error); 返回空值； } } 异步清除() { 尝试{ 等待 SecureStore.deleteItemAsync('access_token'); 等待 SecureStore.deleteItemAsync('refresh_token'); 等待 SecureStore.deleteItemAsync('token_expiry'); } 捕获（错误）{ console.error('清除令牌失败:', error); } } 异步 isTokenExpired() { 尝试{ const expiry =等待 SecureStore.getItemAsync('token_expiry'); if (!expiry) 返回 true；返回 Date.now() > parseInt(expiry); } 捕获（错误）{ 返回真； } } } 导出 const tokenStore = new MobileTokenStore(); ### Token Refresh Strategies #### Automatic Token Refresh (Proactive) // 过期前主动刷新令牌类 TokenRefreshManager { 构造函数（refreshCallback，expiresIn）{ this.refreshCallback=refreshCallback; this.expiresIn = expiresIn; this.refreshTimer = null; } 调度刷新() { // 过期前5分钟刷新常量刷新 = (this.expiresIn - 300) * 1000; if (this.refreshTimer) { 清除超时(this.refreshTimer); } this.refreshTimer = setTimeout(async () => { 尝试{ await this.refreshCallback(); } 捕获（错误）{ console.error('令牌刷新失败：', error); // 可选：重定向到登录 } }，刷新）； } 取消刷新() { if (this.refreshTimer) { 清除超时(this.refreshTimer); this.refreshTimer = null; } } } // 用法常量刷新管理器 = 新的 TokenRefreshManager( 异步（）=> { // Refresh token logic const newTokens = 等待刷新Tokens(); setAccessToken(newTokens.access_token); freshManager.expiresIn = newTokens.expires_in; refreshManager.scheduleRefresh(); }, 第3600章）； // Start automatic refresh 刷新管理器.scheduleRefresh(); #### 按需令牌刷新（反应式） // 仅当访问令牌过期时刷新令牌类 ReactiveTokenManager { 构造函数（）{ this.accessToken = null; this.expiresAt = null; this.refreshPromise = null; // 防止并发刷新 } 异步 getValidToken() { // 检查token是否仍然有效 if (this.accessToken && Date.now() < this.expiresAt - 60000) { 返回 this.accessToken; } // Token过期，刷新 if (!this.refreshPromise) { this.refreshPromise = this.refreshToken() .finally(() => { this.refreshPromise = null; }); } 等待这个.refreshPromise；返回 this.accessToken; } 异步刷新令牌() { const 响应 = 等待 fetch('/api/auth/refresh', { 方法：'POST'，凭证：'include'，//发送刷新令牌cookie }); 如果（！response.ok）{ throw new Error('令牌刷新失败'); } const tokens =等待response.json(); this.accessToken = tokens.access_token; this.expiresAt = Date.now() + (tokens.expires_in * 1000); 返回 this.accessToken; } 清除令牌（）{ this.accessToken = null; this.expiresAt = null; this.refreshPromise = null; } } // API 客户端中的使用 const tokenManager = new ReactiveTokenManager(); 异步函数 makeApiRequest(端点) { const token = wait tokenManager.getValidToken(); const 响应 = 等待获取（端点，{ 标题：{ '授权': `不记名${token}`, }, }); 返回响应； } ### 令牌撤销 // 实现令牌撤销异步函数 revokeToken(token, tokenTypeHint = 'access_token') { const 响应 = 等待 fetch('https://auth.example.com/oauth/revoke', { 方法：'POST'，标题：{ '内容类型': 'application/x-www-form-urlencoded', }, 正文：新的 URLSearchParams({ 令牌：令牌， token_type_hint: tokenTypeHint, // 'access_token' 或 'refresh_token' client_id：oauth2Config.clientId， client_secret: oauth2Config.clientSecret, // 如果是机密客户端 }), }); 如果（！response.ok）{ throw new Error('令牌撤销失败'); } 返回真； } // 注销并撤销令牌异步函数注销() { 尝试{ // 撤销访问令牌如果（访问令牌）{ 等待 revokeToken(accessToken, 'access_token'); } // 撤销刷新令牌如果（刷新令牌）{ 等待 revokeToken(refreshToken, 'refresh_token'); } // 清除本地状态清除令牌（）； // 可选：重定向到注销端点以进行会话清理 window.location.href = 'https://auth.example.com/logout?redirect_uri=' + 编码URIComponent(window.location.origin); } 捕获（错误）{ console.error('注销失败：', error); // 无论如何都要清除标记清除令牌（）； } } ## OAuth2 服务器实现 ### 构建授权服务器 **实现 OAuth2 提供程序功能** #### 授权端点 // Express.js 授权端点 const express = require('express'); const crypto = require('crypto'); const 路由器 = Express.Router(); router.get('/oauth/authorize', async (req, res) => { 常量{ 客户端_id，重定向_uri，响应类型，范围，状态，代码挑战，代码_挑战_方法， } = 请求.查询; // 验证所需参数 if (!client_id || !redirect_uri || !response_type) { 返回 res.status(400).json({ 错误：'无效请求'， error_description: '缺少必需的参数', }); } // 验证client_id和redirect_uri const client = 等待 getClient(client_id); 如果（！客户端）{ 返回 res.status(400).json({ 错误：'无效的客户端'， error_description: '未知客户端', }); } if (!client.redirect_uris.includes(redirect_uri)) { 返回 res.status(400).json({ 错误：'无效请求'， error_description: '无效的redirect_uri', }); } // 验证response_type if (response_type !== '代码') { 返回redirectWithError（redirect_uri，状态，'unsupported_response_type'， '仅支持授权码流程'); } // 验证 PKCE 参数如果（代码挑战）{ 如果（！code_challenge_method）{ 返回redirectWithError（redirect_uri，状态，'invalid_request'， '使用 PKCE 时需要 code_challenge_method'); } if (code_challenge_method !== 'S256' && code_challenge_method !== 'plain') { 返回redirectWithError（redirect_uri，状态，'invalid_request'， '不支持的code_challenge_method'); } } // 检查用户是否通过身份验证 if (!req.session.userId) { // 存储授权请求并重定向到登录 req.session.authRequest = { 客户端_id，重定向_uri，范围，状态，代码挑战，代码_挑战_方法， }; return res.redirect('/login? continue=' +encodeURIComponent(req.originalUrl)); } // 用户已通过身份验证，显示同意屏幕 res.render('同意', { 客户：客户，范围：范围？范围.split(' ') : [], 状态：状态， }); }); // 同意端点 router.post('/oauth/consent', async (req, res) => { const { 已批准 } = req.body; const authRequest = req.session.authRequest; 如果（！authRequest）{ return res.status(400).send('没有待处理的授权请求'); } 如果（已批准！=='真'）{ // 用户拒绝同意返回重定向错误（ authRequest.redirect_uri, authRequest.state, '访问被拒绝', “用户拒绝同意” ）； } // 生成授权码 constauthorizationCode = crypto.randomBytes(32).toString('hex'); // 存储授权码和元数据等待 storeAuthorizationCode(authorizationCode, { client_id: authRequest.client_id, redirect_uri: authRequest.redirect_uri, user_id: req.session.userId, 范围：authRequest.scope，代码挑战：authRequest.code_challenge， code_challenge_method：authRequest.code_challenge_method， expires_at: Date.now() + 600000, // 10 分钟 }); // 清除会话中的身份验证请求删除req.session.authRequest； // 重定向到带有授权码的客户端 const redirectUrl = 新 URL(authRequest.redirect_uri); redirectUrl.searchParams.set('code',authorizationCode); 如果（authRequest.state）{ redirectUrl.searchParams.set('state', authRequest.state); } res.redirect(redirectUrl.toString()); }); 函数redirectWithError（redirectUri，状态，错误，错误描述）{ const url = 新 URL(redirectUri); url.searchParams.set('错误', 错误); url.searchParams.set('error_description', errorDescription); 如果（状态）{ url.searchParams.set('状态', 状态); } 返回 res.redirect(url.toString()); } #### 令牌端点 // 令牌端点实现 router.post('/oauth/token', async (req, res) => { const { grant_type } = req.body; 尝试{ 让令牌；开关（授予类型）{ 案例“授权代码”：令牌=等待handleAuthorizationCodeGrant(req.body); 打破；案例“refresh_token”：令牌=等待handleRefreshTokenGrant(req.body); 打破；案例“client_credentials”：令牌=等待handleClientCredentialsGrant(req.body); 打破；默认：返回 res.status(400).json({ 错误：“不支持的授权类型”， error_description: `不支持授予类型'${grant_type}'`, }); } res.json(令牌); } 捕获（错误）{ console.error('令牌端点错误：', error); res.status(400).json({ 错误：错误代码 || '无效请求', error_description: 错误消息， }); } }); 异步函数handleAuthorizationCodeGrant(params) { 常量{ 代码，重定向_uri，客户端_id，客户秘密，代码验证者， } = 参数； // 验证所需参数 if (!code || !redirect_uri || !client_id) { throw { code: 'invalid_request', message: '缺少必需参数' }; } // 获取授权码 const authCode = 等待 getAuthorizationCode(code); 如果（！authCode）{ throw { code: 'invalid_grant', message: '无效的授权码' }; } // 检查过期时间 if (Date.now() > authCode.expires_at) { 等待删除授权码（代码）； throw { code: 'invalid_grant', message: '授权码已过期' }; } // 验证客户端 if (authCode.client_id !== client_id) { throw { code: 'invalid_grant', message: '客户端不匹配' }; } // 验证重定向 URI if (authCode.redirect_uri !=redirect_uri) { throw { code: 'invalid_grant', message: '重定向 URI 不匹配' }; } // 验证客户端 const client = 等待 getClient(client_id); if (client.client_type === '机密') { // 保密客户端必须提供client_secret if (client.client_secret !== client_secret) { throw { code: 'invalid_client', message: '无效的客户端凭据' }; } } // 验证 PKCE（如果使用）如果（authCode.code_challenge）{ 如果（！code_verifier）{ throw { code: 'invalid_request', message: '需要 code_verifier' }; } const isValid = validatePKCE( 代码验证者， authCode.code_challenge, authCode.code_challenge_method ）；如果（！isValid）{ throw { code: 'invalid_grant', message: '无效的 code_verifier' }; } } // 删除授权码（一次性使用）等待删除授权码（代码）； // 生成令牌 const accessToken = 等待生成AccessToken({ user_id: authCode.user_id, 客户端_id：客户端_id，范围：authCode.scope， }); 常量刷新令牌 = 等待生成刷新令牌（{ user_id: authCode.user_id, 客户端_id：客户端_id，范围：authCode.scope， }); // 如果请求 openid 范围，则生成 ID 令牌让 idToken = null; if (authCode.scope && authCode.scope.includes('openid')) { idToken = 等待生成IDToken({ user_id: authCode.user_id, 客户端_id：客户端_id，范围：authCode.scope， }); } 常量响应 = { 访问令牌：访问令牌， token_type: '承载者', 过期时间：3600，刷新令牌：刷新令牌， }; 如果（idToken）{ 响应.id_token = idToken; } 返回响应； } 函数 validatePKCE(codeVerifier, codeChallenge, 方法) { if (方法 === '普通') { 返回 codeVerifier === codeChallenge; } 如果（方法==='S256'）{ const hash = crypto.createHash('sha256').update(codeVerifier).digest(); const 计算 = base64UrlEncode(hash); 返回计算 === codeChallenge; } 返回假； } 异步函数handleRefreshTokenGrant（params）{ const { 刷新令牌、客户端 ID、客户端秘密、范围 } = 参数； // 验证刷新令牌 const storeToken = 等待 getRefreshToken(refresh_token); 如果（！storedToken）{ throw { code: 'invalid_grant', message: '无效的刷新令牌' }; } // 检查是否被撤销如果（storedToken.revoked）{ throw { code: 'invalid_grant', message: '刷新令牌已被撤销' }; } // 验证客户端 if (storedToken.client_id !== client_id) { throw { code: 'invalid_grant', message: '客户端不匹配' }; } const client = 等待 getClient(client_id); if (client.client_type === '机密' && client.client_secret !== client_secret) { throw { code: 'invalid_client', message: '无效的客户端凭据' }; } // 验证范围（请求的范围必须是原始范围的子集）常量 requestScopes = 范围 ? scope.split(' ') :storedToken.scope.split(' '); const originScopes =storedToken.scope.split(' '); const isValidScope =requestedScopes.every(s =>originalScopes.includes(s)); 如果（！isValidScope）{ throw { code: 'invalid_scope', message: '请求的范围超出原始授权' }; } // 生成新的访问令牌 const accessToken = 等待生成AccessToken({ user_id：storedToken.user_id，客户端_id：客户端_id，范围：requestedScopes.join(' '), }); // 可选：刷新令牌轮换让newRefreshToken =刷新令牌；如果（shouldRotateRefreshToken（））{ // 撤销旧的刷新令牌等待撤销RefreshToken（refresh_token）； // 生成新的刷新令牌 newRefreshToken = 等待生成RefreshToken({ user_id：storedToken.user_id，客户端_id：客户端_id，范围：requestedScopes.join(' '), }); } 返回{ 访问令牌：访问令牌， token_type: '承载者', 过期时间：3600，刷新令牌：新的刷新令牌，范围：requestedScopes.join(' '), }; } 异步函数handleClientCredentialsGrant(params) { const { client_id, client_secret, 范围 } = params; // 验证客户端 const client = 等待 getClient(client_id); if (!client || client.client_secret !== client_secret) { throw { code: 'invalid_client', message: '无效的客户端凭据' }; } // 验证范围如果（范围）{ const requestScopes = scope.split(' '); const allowedScopes = client.allowed_scopes || []； const isValidScope = requestScopes.every(s => allowedScopes.includes(s)); 如果（！isValidScope）{ throw { code: 'invalid_scope', message: '该客户端不允许请求的范围' }; } } // 生成访问令牌（客户端凭据没有刷新令牌） const accessToken = 等待生成AccessToken({ 客户端_id：客户端_id，范围：范围||客户端.default_scope, }); 返回{ 访问令牌：访问令牌， token_type: '承载者', 过期时间：3600，范围：范围||客户端.default_scope, }; } #### 令牌生成（JWT） // JWT 令牌生成 const jwt = require('jsonwebtoken'); const fs = require('fs'); const privateKey = fs.readFileSync('path/to/private-key.pem'); const publicKey = fs.readFileSync('path/to/public-key.pem'); 异步函数generateAccessToken(payload) { const 标记 = jwt.sign( { 子：payload.user_id ||负载.client_id, client_id：payload.client_id，范围：有效负载.范围， iat: Math.floor(Date.now() / 1000), exp: Math.floor(Date.now() / 1000) + 3600, // 1 小时 iss: 'https://auth.example.com', aud: 'https://api.example.com', }, 私钥， { 算法：'RS256'， keyid: 'key-id-1', } ）；返回令牌； } 异步函数generateRefreshToken（有效负载）{ const refreshToken = crypto.randomBytes(32).toString('hex'); // 将刷新令牌存储在数据库中等待 storeRefreshToken(refreshToken, { user_id：payload.user_id， client_id：payload.client_id，范围：有效负载.范围，创建时间：Date.now(), expires_at: Date.now() + (30 * 24 * 60 * 60 * 1000), // 30 天撤销：假， }); 返回刷新令牌； } 异步函数generateIDToken(payload) { const user = wait getUser(payload.user_id); const idToken = jwt.sign( { iss: 'https://auth.example.com', 子：payload.user_id， aud：payload.client_id， exp: Math.floor(Date.now() / 1000) + 3600, iat: Math.floor(Date.now() / 1000), // 标准声明名称：用户名，电子邮件：用户.电子邮件，电子邮件验证：用户.电子邮件验证，图片：用户.图片， // 基于范围的自定义声明 ...getScopedClaims(用户，有效负载.范围)， }, 私钥， { 算法：'RS256'， keyid: 'key-id-1', } ）；返回idToken； } 函数 getScopedClaims(用户, 范围) { 常量声明= {}；常量作用域 = 作用域？范围.split(' ') : []; if (scopes.includes('profile')) { 声明.given_name = user.given_name; 声明.family_name = 用户.family_name; 声明.locale = user.locale; 声明.updated_at = user.updated_at; } if (scopes.includes('phone')) { 声明.电话号码 = 用户.电话号码; Claims.phone_number_verified = user.phone_number_verified; } 退货索赔； } ## 最佳实践和安全性 ### 安全最佳实践 1. **始终使用 HTTPS** * 所有 OAuth2 端点必须使用 HTTPS * 令牌仅通过加密连接传输 * 没有通过 HTTP 的 OAuth2（本地主机开发除外） 2. **严格验证重定向 URI** * 需要精确匹配（无通配符） * 提前注册所有重定向URI * 验证每个授权请求 3. **对公共客户端使用 PKCE** * SPA 和移动应用程序需要 * 使用S256代码质询方法（非明文） * 防止授权码拦截 4. **实现状态参数** * 防止CSRF攻击 * 生成加密安全的随机值 * 回调时验证 5. **短期访问令牌** * 通常为 15 分钟至 1 小时 * 减少代币被盗的影响 * 对长期会话使用刷新令牌 6. **安全令牌存储** * 切勿将令牌存储在 localStorage 中（XSS 风险） * 使用 httpOnly cookie 来刷新令牌 * 移动端：使用平台安全存储（Keychain、Keystore） 7. **实施代币轮换** * 每次使用时轮换刷新令牌 * 通过多次刷新尝试检测令牌盗窃 * 撤销所有受损刷新令牌的令牌 8. **验证所有令牌** * 验证JWT签名 * 检查过期时间 * 验证发行者和受众 * 验证所需范围 9. **基于范围的访问控制** * 请求最小所需范围 * 验证 API 请求的范围 * 记录所有可用范围 10. **监控和日志** * 记录所有身份验证尝试 * 监控可疑模式 * 多次尝试失败时发出警报 * 跟踪令牌的使用和撤销 ### 要避免的常见陷阱 1. **使用隐式流** * 已弃用且不安全 * 使用带有 PKCE 的授权代码流程 2. **将Token存储在localStorage** * 容易受到 XSS 攻击 * 使用内存或安全存储代替 3. **不验证重定向 URI** * 启用开放重定向攻击 * 始终根据注册的 URI 进行验证 4. **忽略令牌过期** * 过期的令牌应该被拒绝 * 实现适当的刷新逻辑 5. **不使用状态参数** * 容易受到CSRF攻击 * 始终生成并验证状态 6. **长期访问令牌** * 增加安全风险 * 保持访问令牌短暂（15-60 分钟） 7. **在应用程序之间共享令牌** * 令牌应该是特定于应用程序的 * 每个应用程序应该有自己的client_id 8. **弱代码验证器（PKCE）** * 使用加密安全随机生成 * 最少 43 个字符 9. **不实施令牌撤销** * 用户无法撤销访问权限 * 受损的代币仍然有效 10. **日志记录不足** * 无法检测或调查安全事件 * 记录所有认证和授权事件 ## 性能优化 ### 令牌缓存 // 具有自动刷新功能的高效令牌缓存类 OptimizedTokenManager { 构造函数（）{ this.tokenCache = new Map(); this.refreshPromises = new Map(); } 异步 getToken(cacheKey, fetchCallback) { // 检查缓存 const 缓存 = this.tokenCache.get(cacheKey); if (cached && Date.now() < cached.expiresAt - 60000) { 返回缓存的令牌； } // 检查刷新是否正在进行 if (this.refreshPromises.has(cacheKey)) { 返回 this.refreshPromises.get(cacheKey); } // 获取新的令牌 const 承诺 = fetchCallback() .then(({ 令牌, expiresIn }) => { this.tokenCache.set(cacheKey, { 令牌，过期时间：Date.now() + (expiresIn * 1000), }); this.refreshPromises.delete(cacheKey); 返回令牌； }) .catch（错误=> { this.refreshPromises.delete(cacheKey); 抛出错误； }); this.refreshPromises.set(cacheKey, Promise); 回报承诺； } 清除缓存（缓存键）{ if (缓存键) { this.tokenCache.delete(cacheKey); } 否则{ this.tokenCache.clear(); } } } ### 连接池 // 重用 HTTP 连接进行令牌请求 const https = require('https'); const axios = require('axios'); const httpsAgent = 新 https.Agent({ 保持活动：真实，最大套接字数：50，最大空闲套接字：10，超时：60000， }); const apiClient = axios.create({ https代理，超时：30000， }); // 用于所有 OAuth2 请求异步函数 fetchTokens(params) { const 响应 = 等待 apiClient.post(tokenEndpoint, params); 返回响应数据； } ## 资源和参考 ### 官方规格 * [RFC 6749 - OAuth 2.0 授权框架]() * [RFC 7636 - PKCE]() * [RFC 8252 - 适用于本机应用程序的 OAuth 2.0]() * [OpenID Connect 核心 1.0]() * [OAuth 2.0 安全最佳实践]() ### 流行的 OAuth2 库 **JavaScript/Node.js：** * `passport` \- 身份验证中间件 * `oauth4webapi` \- 现代 OAuth2 客户端 * `node-oauth2-server` \- OAuth2 服务器实现 * `jsonwebtoken` \- JWT 创建和验证 * `jwks-rsa` \- JWKS 密钥检索 **Python：** * `authlib` \- 综合 OAuth 库 * `python-oauth2` \- OAuth2 提供者工具包 * `PyJWT` \- JWT 实现 **PHP：** * `league/oauth2-client` \- OAuth2 客户端 * `league/oauth2-server` \- OAuth2 服务器 **Java：** * Spring安全OAuth *阿帕奇·奥尔图 ### OAuth2 提供商 * 授权0 *奥克塔 * 亚马逊认知 * 谷歌身份平台 * Azure 活动目录 * Keycloak（开源） * ORY Hydra（开源） ** ** **技能版本**：1.0.0 **最后更新**：2025 年 10 月 **技能类别**：身份验证、授权、安全 **兼容**：Web 应用程序、移动应用程序、API、微服务

Oauth2认证

包含技能