一、先说问题:授权码是怎么泄露的?

授权码模式是 OAuth 2.0 里最常见的登录方式,不管你是做网站登录、小程序登录,还是接入第三方开放平台,只要用到授权码模式,都会面对一个绕不开的话题:授权码一旦被人偷走,你的用户登录态就危险了。

它的运行逻辑听起来很合理:用户不把密码直接交给你,而是去授权服务器登录,登录成功后授权服务器给你一个随机授权码,你再拿这个授权码去换访问令牌。问题在于,这个授权码要在浏览器和你的服务器之间来回传递,中间只要有一双眼睛盯着,它就可能被偷走。

常见的泄露渠道有很多。第一,授权码通常放在 URL 参数里,浏览器会把完整的地址存进历史记录,别人只要打开同一台电脑翻一下浏览历史,就能看到。第二,很多服务器框架会把请求参数自动打印到日志里,日志一旦被上传或者被拖走,授权码就等于白送。第三,页面里如果引用了第三方脚本,比如统计代码、广告 JS,它们理论上也能读到当前页面地址,把授权码顺手带走。第四,如果用户点击了某个恶意链接,之前页面的地址会出现在 Referer 字段里发给新站点,授权码也可能跟着出去。

你可能会想:“授权码不是一次性的吗?而且很快就过期了,偷走能有什么用?”想法很美好,现实很残酷。如果对方在极短的时间内用这个授权码去换令牌,而你的服务端没有做额外校验,那授权码就能直接换到完整登录态。更糟的是,有些授权服务器允许授权码用多次,或者换完令牌后没有立刻作废,攻击者就可以反复利用。

明白了风险,我们接下来就看看怎么堵。

二、解决思路:从源头堵住漏洞

要让授权码不泄露,光靠“别被别人看到”是做不到的,因为你在明处,攻击者往往躲在暗处。所以我们要做的是:让泄露出去的授权码也换不到令牌,或者让伪造的授权请求根本没法成功。

2.1 回调地址必须锁死

授权码是通过回调地址传给你的应用的,如果回调地址可以随便写,攻击者就能诱导授权服务器把授权码发到他自己的服务器上。所以第一步,一定要在授权服务器上维护一个白名单,只允许注册过的回调地址。这个白名单要精确匹配,绝对不能搞模糊匹配,否则人家只要在域名上加个前缀或者路径就能绕过去。

下面用 Node.js 模拟授权服务器端的校验逻辑(技术栈:Node.js):

// 这个 Set 模拟数据库里存的合法回调地址
const allowedRedirectUris = new Set([
  'https://your-app.com/callback',
  'https://your-app.com/login/callback'
]);

// 授权服务器的授权接口
app.get('/oauth/authorize', (req, res) => {
  const { redirect_uri, client_id } = req.query;

  // 1. 正常应该先核对 client_id 是否存在,这里省略查库
  // 2. 再核对回调地址是否在白名单里
  if (!redirect_uri || !allowedRedirectUris.has(redirect_uri)) {
    return res.status(400).send('回调地址不合法');
  }

  // 3. 如果都合法,才继续后面的授权流程
  // ... 让用户登录并授权
});

注意:这里用的是 Set.has 做精确匹配,千万别用 includes 之类的模糊判断。有些开发图省事,写一个 redirect_uri.startsWith('https://your-app.com'),那攻击者构造一个 https://your-app.com.evil.com 就能骗过去,这种坑一定要避开。

2.2 用 PKCE 让授权码和验证器绑定

PKCE(Proof Key for Code Exchange,码交换证明钥匙)是专门对付授权码被截获的。原理很简单:你的客户端自己生成一个随机串,叫做 code_verifier,然后算出一个变形值,叫做 code_challenge,在发起授权请求时把 code_challenge 发过去。换令牌的时候,客户端要把原始的 code_verifier 也发过去。授权服务器会校验这两者的关系是否匹配。攻击者就算拿走了授权码,没有那个原始的 code_verifier,照样换不到令牌。

PKCE 本来是为移动端设计的,因为原生应用没法安全保存客户端密钥。但现在 Web 应用也强烈建议用,尤其是纯前端场景。一般用 S256 方式,也就是对 code_verifier 做 SHA256 哈希,再做 base64url 编码,这样网络传输时不会暴露原始值。

生成这两个参数可以用 Node.js 自带的 crypto 模块(技术栈:Node.js):

const crypto = require('crypto');

// 把 Buffer 转成 base64url 字符串(URL 安全格式)
function base64urlEncode(buffer) {
  return buffer.toString('base64')
    .replace(/\+/g, '-')   // 把 + 换成 -
    .replace(/\//g, '_')   // 把 / 换成 _
    .replace(/=+$/, '');   // 去掉末尾的 =
}

// 生成 32 字节的随机数作为 code_verifier
function generateCodeVerifier() {
  return base64urlEncode(crypto.randomBytes(32));
}

// 用 S256 算法生成 code_challenge
function generateCodeChallenge(verifier) {
  const hash = crypto.createHash('sha256').update(verifier).digest();
  return base64urlEncode(hash);
}

生成之后,把 code_challenge 放进授权请求里,同时带上 code_challenge_method=S256。注意 code_verifier 必须保存在客户端自己的服务端,不能放在 URL 参数里,否则等于白做。

2.3 用 state 参数防 CSRF

很多人忽略 state 参数,但它其实很重要。它的作用是防止“登录 CSRF”。攻击者可以构造一个授权链接诱骗用户点击,然后用户带着攻击者准备好的授权码回来,你的应用可能稀里糊涂地接受了这个授权码,再去换令牌,造成会话固定攻击。加一个随机 state,并在回调时核对它是不是自己当初生成的,就能防住这一招。

state 的生成很简单,参考下面的代码(技术栈:Node.js):

// 生成一个随机的 state 值
function generateState() {
  return base64urlEncode(crypto.randomBytes(16));
}

关键是保存和校验。你需要在发起授权时把它存到会话或临时存储里,回调时取出来逐字符比对。如果对不上,直接拒绝。同时,校验过后马上删掉,防止同一个 state 被重放。

2.4 授权码要短命且只能用一次

授权码不能“长生不老”,它只应该存活几秒钟到几分钟,并且只能兑换一次。很多授权服务器默认就实现了这些,但作为客户端也要注意:不要在服务器端缓存授权码,拿到就立刻换令牌,换完就丢。同时,如果换令牌时收到错误,也要让授权码立即失效。

三、完整实战示例:一次安全的授权码请求

下面用 Node.js 写一个完整的客户端示例(技术栈:Node.js + Express)。我们使用 Express 作为 Web 框架,用 axios 发请求。整个流程包含:生成 PKCE 参数、生成并保存 state、跳转到授权页、回调时校验 state、用 code 和 verifier 换令牌。这里假设授权服务器已经实现了回调地址白名单和一次性授权码校验。

首先安装依赖:

npm install express axios

然后创建 app.js,代码如下:

const express = require('express');
const crypto = require('crypto');
const axios = require('axios');

const app = express();
const stateStore = new Map(); // 内存保存 state -> verifier 的映射

// ---------- 工具函数 ----------

// 将 Buffer 转为 base64url 格式(URL 中安全)
function base64url(buffer) {
  return buffer.toString('base64')
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=+$/, '');
}

// 生成 32 字节的 code_verifier
function generateCodeVerifier() {
  return base64url(crypto.randomBytes(32));
}

// 用 SHA256 哈希生成 code_challenge
function generateCodeChallenge(verifier) {
  const hash = crypto.createHash('sha256').update(verifier).digest();
  return base64url(hash);
}

// 生成随机 state
function generateState() {
  return base64url(crypto.randomBytes(16));
}

// ---------- 路由 ----------

// 步骤1:用户访问 /login,我们发起授权请求
app.get('/login', (req, res) => {
  // 生成 PKCE 参数
  const verifier = generateCodeVerifier();
  const challenge = generateCodeChallenge(verifier);

  // 生成 state 并保存 verifier
  const state = generateState();
  stateStore.set(state, verifier);

  // 拼授权 URL。注意 redirect_uri 必须和注册时完全一致
  const authUrl = 'https://auth.example.com/oauth/authorize?' +
    'response_type=code' +
    '&client_id=' + encodeURIComponent('your-client-id') +
    '&redirect_uri=' + encodeURIComponent('https://your-app.com/callback') +
    '&scope=openid' +
    '&state=' + state +
    '&code_challenge=' + challenge +
    '&code_challenge_method=S256';

  // 让浏览器跳转到授权服务器
  res.redirect(authUrl);
});

// 步骤2:授权服务器回调到 /callback
app.get('/callback', async (req, res) => {
  const { code, state } = req.query;

  // 如果授权失败,服务器可能带 error 参数
  if (req.query.error) {
    return res.status(400).send('授权失败: ' + req.query.error);
  }

  // 校验 state:从存储中找对应的 verifier
  const verifier = stateStore.get(state);
  if (!verifier) {
    return res.status(403).send('state 校验失败,请求可能被篡改');
  }

  // 立即删除,防止同一个 state 被重放
  stateStore.delete(state);

  // 如果没有 code,也拒绝
  if (!code) {
    return res.status(400).send('缺少授权码');
  }

  try {
    // 用 code + code_verifier 换取访问令牌
    const tokenRes = await axios.post('https://auth.example.com/oauth/token', 
      new URLSearchParams({
        grant_type: 'authorization_code',
        code: code,
        redirect_uri: 'https://your-app.com/callback',
        client_id: 'your-client-id',
        code_verifier: verifier
      }),
      {
        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
      }
    );

    const accessToken = tokenRes.data.access_token;
    // 这里你应该把 token 保存在服务端,而不是返回给前端
    // 下面这行只是为了演示流程,生产环境绝对不能这样做
    res.send('成功获取令牌: ' + accessToken);
  } catch (err) {
    // 换令牌出错,可能是授权码过期、重复使用或 verifier 不匹配
    res.status(500).send('换取令牌失败:' + err.message);
  }
});

app.listen(3000, () => {
  console.log('应用已启动,访问 http://localhost:3000/login');
});

代码里的注释已经说明了关键点。特别提醒:stateStore 用 Map 只是为了演示,生产环境应该用 Redis 这类集中存储,并且要加过期时间。另外,access_token 绝对不能直接返回给前端,这里只是临时展示。

四、技术优缺点对照

每种方案都不是银弹,咱们把它们的优缺点放到一起看,心里更有数。

先看回调地址白名单。优点是实现简单,能直接挡住大量回调地址被篡改的攻击,属于基础防护。缺点是只能由授权服务器强约束,如果授权服务器没做这个,客户端再努力也白搭。所以选授权服务商时,一定要确认它支持精确回调校验。

再看 PKCE。最大优点是即使授权码被截获,没有 code_verifier 也换不到令牌,而且 verifier 只保存在客户端自己的服务端,网络层不传输原始值。缺点是客户端需要额外生成随机数和做哈希,遇到老旧的授权服务器可能不支持 S256,得用 plain 方式,但 plain 方式强度不够,不推荐。

state 参数能防 CSRF,实现成本很低,就是一个随机字符串的比对。但它不能防授权码泄露,因为 state 本身跟令牌无关。另外,state 的保存和校验也有讲究,如果存到 Cookie 里,要注意同名问题。

一次性授权码和短过期是授权服务器端的策略。优点是能显著缩短攻击者的利用窗口,把泄露的影响降到最低。缺点是需要服务器端维护状态,比如记录哪些授权码已使用、何时过期。有些授权服务器可能默认允许授权码用多次,这时客户端就要在业务上做额外判断,或者在发现异常时主动撤销令牌。

五、注意事项

即便用了上面的方案,还是有一些容易踩的坑要特别注意。

第一,日志里不要记录授权码。很多框架在打印请求 URL 时会把整个 query 打出来,code 参数就裸奔了。建议在日志中间件里过滤掉 code、state、token 这些敏感字段。

第二,必须在 HTTPS 环境下跑。如果走 HTTP,授权码在网络上就是明文传输,抓包就能看到,之前做的 PKCE 也就作用有限了。因为 PKCE 主要防的是被第三方拿到 code 后换 token,但抓包者如果看到了你的 token 请求,同样能看到 verifier。所以 HTTPS 是底线。

第三,不要在前端存 code_verifier。有些同学觉得浏览器本地存储很方便,就把 verifier 放 localStorage,这等于把保险箱钥匙放在保险箱旁边。应该只保存在你的后端服务内存或服务器 Session 里。

第四,回调地址的比对要区分大小写和路径。https://your-app.com/callback 和 https://your-app.com/Callback 是两回事,别因为大小写不敏感就放行。

第五,别用 openssl rand -base64 32 之类的命令在命令行生成 verifier,然后在代码里写死。每个授权请求都必须重新生成,不然又等于共享密钥。

第六,授权服务器返回的授权码要妥善处理。有些框架会在前端跳转时把 code 暴露给浏览器端 JS,这其实没必要。最好由后端接收并立刻消费,前端只负责跳转。

第七,注意第三方 SDK 的行为。你引入的 OAuth 库可能自己管 state 和 verifier,也可能需要你手动提供。用的时候要读文档,确认它默认开启了这些保护,别以为框架替你做了。

六、文章总结

授权码泄露问题不是一个点上的事,而是整条链路上的攻防。回调地址白名单挡住第一层,PKCE 把授权码和验证器绑定,state 防住 CSRF,一次性授权码和短过期压缩利用窗口。把这些都用上,哪怕授权码真被截获,攻击者也很难把它变成实际的危害。

开发上别贪图简单,更别觉得自己是创业项目就没黑客盯。安全这东西,多做一步就多一层保险。希望这篇文章里的示例和思路能帮你把授权码流程做得更扎实。