时间线:

  • GitHub Security Advisory 披露:2026-07-08
  • NVD 收录:2026-08-13
  • 本文验证日期:2026-08-16

影响版本:

  • < 3.2.7
  • >= 4.0.0, < 4.1.10
  • >= 5.0.0-beta.1, < 5.0.0-beta.6

修复版本:

  • 3.2.7
  • 4.1.10
  • 5.0.0-beta.6

CVSS 3.1(GitHub CNA):9.4 CRITICAL

TL;DR

CVE-2026-73653 的核心不是单个路径遍历点,而是 Vitest Browser Mode 里多条 browser -> RPC -> provider -> filesystem 链路同时缺失统一的权限检查。

脆弱版本中,浏览器侧可控参数最终进入下面这些命令:

  • upload
  • takeScreenshot
  • screenshotMatcher
  • stopChunkTrace
  • deleteTracing
  • annotateTraces

这些命令在修复前要么没有执行 allowWrite 检查,要么没有执行 server.fs 边界检查,要么两者都没有。结果是攻击者只要能触达 Browser Mode API,就可能在 Vitest 进程权限范围内获得本地文件读、写、删或外带能力;其中具体能打到哪些原语,还取决于底层 provider。

1. 执行架构:为什么浏览器代码能触达本地文件系统

理解这个漏洞,先要理解 Vitest Browser Mode 的执行边界。

表面上测试代码跑在浏览器里,但 Browser Mode 并不只是浏览器内脚本。浏览器侧的很多 API 调用,最终会被转发给 Node.js 侧命令处理器,再由 provider 去调用 Playwright 或 WebdriverIO 的本地能力。

抽象后的结构是:

图 1-1:Browser Mode 中浏览器侧调用如何跨过 RPC 边界进入 provider,并最终触达本地文件系统、trace 或 artifact 流程。

安全边界本来应该出现在两个地方:

  1. 浏览器传上来的路径,必须先过 server.fs 约束
  2. 涉及写入、删除的动作,必须先过 allowWrite 约束

这个 CVE 的问题在于,框架内部确实存在安全边界概念,但这些 provider commands 没有统一复用它。

也就是说,产品里同时存在:

  • 一套“受控文件访问”逻辑
  • 一批“绕过这套逻辑的内部捷径”

漏洞就是后者。

2. 根因概述

浏览器侧可控路径在穿过 RPC 边界后,被 provider 命令直接拼接、规范化或透传给文件系统 API,但没有统一授权和路径边界检查。

这会产生四类攻击后果:

类别

对应命令

后果

任意读取

upload

读取本地文件内容

任意写入

takeScreenshot, screenshotMatcher, stopChunkTrace

写 PNG 或 trace 文件

任意删除

deleteTracing

删除本地文件

文件外带

annotateTraces

借 artifact attachment 带出本地文件

2.1 真实威胁模型:不是任何 Browser Mode 都等价高危

这个洞的风险判断,不能脱离真实部署方式。

GitHub 官方公告写得很清楚:如果 Browser Mode 只监听 localhost,且运行的测试代码本身可信,那么默认场景下并不存在一个“天然的外部攻击者”能直接打这条链。风险真正抬高,通常发生在下面两类场景:

场景

风险

原因

本机 localhost 调试,测试代码可信

相对较低

缺少低信任主体,漏洞更多体现为隔离模型不严

Browser Mode API 对外暴露,例如 browser.api.host 绑定非本机地址

高

远端客户端可直接走 browser -> RPC -> provider 链

把 allowWrite: false 当作不可信测试代码的隔离边界

高

这次漏洞恰好说明该边界会被内建命令绕过

这也是为什么这个洞一边有 GitHub CNA 给出的 9.4 CRITICAL,一边又不能简单理解成“所有本地开发者默认都会被远程打穿”。

3. 共享调用链:所有危险路径都先经过 triggerCommand

从 CodeQL 结果和源码看,这个洞不是分散无关的几个点,而是共享同一条跨边界分发模型。

最关键的公共节点有四个:

符号

文件

作用

triggerCommand

packages/browser/src/client/tester/context.ts:33-35

浏览器侧通用命令分发入口

triggerCommand

packages/browser/src/client/tester/locators.ts:400-413

locator 体系的命令分发入口

triggerCommand

packages/browser/src/node/rpc.ts:333-366

Node 侧 RPC 总入口

triggerCommand

packages/browser/src/node/rpc.ts:350-356

命令内部二次分发 helper

这意味着浏览器侧 API 一旦能控制参数,参数就会越过 RPC 边界进入 Node 侧 provider。后面的每个 provider command,实际上都在扮演“高权限代理”。

直接看脆弱版源码,这条跨边界分发链其实非常直白:

// packages/browser/src/client/tester/context.ts
function triggerCommand<T>(command: string, args: any[], error?: Error) {
  return getBrowserState().commands.triggerCommand<T>(command, args, error)
}

export function createUserEvent(__tl_user_event_base__?: TestingLibraryUserEvent, options?: TestingLibraryOptions): UserEvent {
  if (__tl_user_event_base__) {
    return createPreviewUserEvent(__tl_user_event_base__, options ?? {})
  }

  const userEvent: UserEvent = {
    upload(element, files: string | string[] | File | File[], options) {
      return convertToLocator(element).upload(files, options)
    },
  } as UserEvent
}

// packages/browser/src/client/tester/locators.ts
public upload(files: string | string[] | File | File[], options?: UserEventUploadOptions): Promise<void> {
  return ensureAwaited(async (error) => {
    const filesPromise = (Array.isArray(files) ? files : [files]).map(async (file) => {
      if (typeof file === 'string') {
        return file
      }
      const bas64String = await new Promise<string>((resolve, reject) => {
        const reader = new FileReader()
        reader.onload = () => resolve(reader.result as string)
        reader.onerror = () => reject(new Error(`Failed to read file: ${file.name}`))
        reader.readAsDataURL(file)
      })

      return {
        name: file.name,
        mimeType: file.type,
        base64: bas64String.slice(bas64String.indexOf(',') + 1),
      }
    })
    return getBrowserState().commands.triggerCommand<void>(
      '__vitest_upload',
      [this.serialize(), await Promise.all(filesPromise), options],
      error,
    )
  })
}

protected triggerCommand<T>(command: string, ...args: any[]): Promise<T> {
  return ensureAwaited(error => triggerCommandWithTrace<T>({
    name: command,
    arguments: args,
    errorSource: error,
  }))
}
// packages/browser/src/node/rpc.ts
async triggerCommand(sessionId, command, testPath, payload) {
  const provider = project.browser!.provider
  const context = Object.assign(
    {
      testPath,
      project,
      provider,
      contextId: sessionId,
      sessionId,
      triggerCommand: (name: string, ...args: any[]) => {
        return project.browser!.triggerCommand(
          name as any,
          context,
          ...args,
        )
      },
    },
    provider.getCommandsContext(sessionId),
  ) as BrowserCommandContext

  return await project.browser!.triggerCommand(
    command as any,
    context,
    ...payload,
  )
}

这里最值得注意的不是某个单点函数,而是 Browser API 从设计上就允许浏览器把参数打进 Node 侧 project.browser!.triggerCommand(...)。后续每个 provider command 是否安全,完全取决于命令实现里有没有自己补权限检查。

3.1 一张表看完整攻击面

命令

主要 provider

浏览器侧可控值

最终 sink

后果

upload

Playwright / WebdriverIO

文件名或路径

setInputFiles(...)

本地文件读取

takeScreenshot

Playwright / WebdriverIO

path

mkdir(...) + screenshot({ path })

任意路径写 PNG

screenshotMatcher

Browser core + provider

reference / actual / diff 输出路径

writeFile(...)

隐式写 reference、actual、diff

stopChunkTrace

Playwright

trace name

tracing.stopChunk({ path })

写 trace 压缩包

deleteTracing

Playwright

traces[]

unlink(...)

任意文件删除

annotateTraces

Playwright + artifact 流程

traces[] / attachment.path

recordArtifact(...) 后续 copy

延迟型文件外带

从这张表可以看出,问题不在某个 API 名字危险,而在于这些命令都共享同一种架构位置:

  • 输入来自浏览器侧
  • 权限发生在 Node/provider 侧
  • 最终触碰的是宿主机文件系统

所以真正该审计的不是单个测试 API,而是:

哪些 command 接受路径参数,以及这些路径在落到 sink 前有没有统一检查

3.2 Provider 差异:不是所有链都同等存在

这一点需要单独说明,因为它决定了“漏洞存在”与“实际可利用原语”之间的差异。

能力

Playwright

WebdriverIO

说明

upload 读取

是

是

官方公告明确把 upload 列为两种 provider 都受影响的读取面

takeScreenshot 写入

是

是

两种 provider 都会把浏览器侧路径带到本地截图落盘

screenshotMatcher 写入

是

间接受影响

matcher 属于 Browser core 逻辑,但底层截图仍依赖 provider

stopChunkTrace / deleteTracing / annotateTraces

是

否

这些链路直接依赖 Playwright tracing 能力

这意味着:

  • 如果目标项目使用的是 Playwright provider,从源码调用链看,读、写、删、外带四类原语都有明确落点;本文的本地复现覆盖了其中读取和显式写入两条主链。
  • 如果目标项目使用的是 WebdriverIO provider,依据官方公告与 provider 调用链,读取面和显式写盘面仍然成立;trace 相关原语不纳入本文的实证范围。
  • 下文凡标注为“已复现”的结论,均指 Playwright provider 下的本地实验结果;涉及 WebdriverIO 的部分,均以公告和源码调用链分析为依据。

这类“框架层漏洞 + provider 差异”的问题比单体组件漏洞更值得警惕,因为同一个 Browser API 表面一致,底层实际暴露出的宿主能力却不完全相同。

4. 最高价值读取链:userEvent.upload() 为什么能变成任意文件读取

4.1 调用链

读取链最短,也最典型:

图 4-1:userEvent.upload() 从浏览器侧一路进入 provider,再把宿主机文件交给 setInputFiles(...)。

对应关键函数:

符号

文件:行

作用

createUserEvent.upload

packages/browser/src/client/tester/context.ts:92-94

浏览器测试 API 入口

Locator.upload

packages/browser/src/client/tester/locators.ts:143-169

序列化路径并触发 __vitest_upload

upload

packages/browser-playwright/src/commands/upload.ts:11-34

Node/provider 侧处理器

resolve

packages/browser-playwright/src/commands/upload.ts:25

基于项目根解析路径,但不会自动把路径限制在项目根内

setInputFiles

packages/browser-playwright/src/commands/upload.ts:33

将宿主文件注入 <input type="file">

4.2 脆弱代码

export const upload: UserEventCommand<(element: SerializedLocator, files: Array<string | {
  name: string
  mimeType: string
  base64: string
}>, options: UserEventUploadOptions) => void> = async (
  context,
  selector,
  files,
  options,
) => {
  const testPath = context.testPath
  if (!testPath) {
    throw new Error(`Cannot upload files outside of a test`)
  }
  const root = context.project.config.root

  const playwrightFiles = files.map((file) => {
    if (typeof file === 'string') {
      return resolve(root, file)
    }
    return {
      name: file.name,
      mimeType: file.mimeType,
      buffer: Buffer.from(file.base64, 'base64'),
    }
  })
  await getDescribedLocator(context, selector).setInputFiles(playwrightFiles as string[], options)
}

4.3 问题成因

这一段的关键问题不在 resolve() 本身,而在于 resolve() 之后没有任何安全断言。resolve(root, file) 只负责路径解析,不会把结果强制限制在项目根目录内;绝对路径会被原样保留,../ 也可能把目标带到项目目录之外。

漏洞成立的逻辑是:

  1. 浏览器侧传入 secret.txt
  2. provider 在 Node 侧把它解析成真实本地路径
  3. 这个路径没有经过 server.fs.deny 或允许目录检查
  4. setInputFiles(...) 把宿主机文件直接喂给页面中的 <input>
  5. 浏览器再通过 input.files[0].text() 把内容读回来

也就是说,upload() 实际上把“本地文件读取”包装成了“正常文件上传”。

从攻击视角看,这条链价值最高,因为它给的是直接内容泄露,而不是间接副作用。

5. 截图写入链:page.screenshot() 为什么能绕过 allowWrite: false

5.1 调用链


图 5-1:page.screenshot() 在 Node/provider 侧经过路径处理后,最终调用 Playwright 落盘。

关键函数如下:

符号

文件:行

作用

screenshot

packages/browser/src/client/tester/context.ts:312-358

浏览器侧 page.screenshot(...) 入口

Locator.screenshot

packages/browser/src/client/tester/locators.ts:199-212

locator 截图入口

screenshot

packages/browser/src/node/commands/screenshot.ts:22-36

Node 侧二次转发到 provider

takeScreenshot

packages/browser-playwright/src/commands/screenshot.ts:32-91

Provider 真正执行截图

resolveScreenshotPath

packages/browser/src/node/utils.ts:45-65

计算目标输出路径

mkdir

packages/browser-playwright/src/commands/screenshot.ts:54

为写文件创建目录

5.2 脆弱代码

export async function takeScreenshot(
  context: BrowserCommandContext,
  name: string,
  options: Omit<ScreenshotCommandOptions, 'base64'>,
): Promise<{ buffer: Buffer<ArrayBufferLike>; path: string }> {
  if (!context.testPath) {
    throw new Error(`Cannot take a screenshot without a test path`)
  }

  const path = resolveScreenshotPath(
    context.testPath,
    name,
    context.project.config,
    options.path,
  )

  let savePath: string | undefined

  if (options.save) {
    savePath = normalize(path)
    await mkdir(dirname(savePath), { recursive: true })
  }

  const mask = options.mask?.map(selector => getDescribedLocator(context, selector))

  const { target, ...config } = options
  const buffer = target === 'page'
    ? await context.page.screenshot({
        ...config,
        mask,
        path: savePath,
      })
    : await getDescribedLocator(context, { selector: 'body', locator: 'locator(\'body\')' }).screenshot({
        ...config,
        mask,
        path: savePath,
      })

  return { buffer, path }
}

5.3 问题成因

这一条链的问题比读取链更直观。

配置明明允许用户声明:

api: {
  allowWrite: false,
}

但是 takeScreenshot() 在 options.save 为真时,仍然直接走:

  1. normalize(path)
  2. mkdir(dirname(savePath))
  3. page.screenshot({ path: savePath })

执行过程是:

  • 没有检查“当前 Browser API 是否允许写”
  • 没有检查“这个路径是否仍在 server.fs 允许范围内”

因此,这个漏洞的本质是“命令实现无视策略层”,而不是“策略层不存在”。

5.4 这条链的边界意义

很多人会把 allowWrite 理解成“防止不可信客户端借 Browser API 修改宿主机文件”的总开关。这个理解本身是对的,而漏洞恰恰在于内建命令没有尊重这个总开关。

所以修复前的真实情况是:

  • 文档宣称有策略
  • 配置里也确实开了策略
  • 但命令实现绕过了策略

这类问题在安全工程里通常比“完全没做权限控制”更难发现,因为开发者会被已有配置项带来的安全感误导。

6. toMatchScreenshot():第二条写盘链

6.1 调用链

图 6-1:toMatchScreenshot() 虽然表面是断言,但在 side effect 分支里仍会进入真实文件写入。

关键符号:

符号

文件:行

作用

toMatchScreenshot

packages/browser/src/client/tester/expect/toMatchScreenshot.ts:11-129

浏览器测试侧入口

screenshotMatcher

packages/browser/src/node/commands/screenshotMatcher/index.ts:76-154

Node 侧 matcher 主处理器

takeScreenshotBuffer

packages/browser/src/node/commands/screenshotMatcher/utils.ts:240-252

复用 __vitest_takeScreenshot 获取截图

performSideEffects

packages/browser/src/node/commands/screenshotMatcher/index.ts:276-307

不同结果分支下执行落盘

writeScreenshot

packages/browser/src/node/commands/screenshotMatcher/index.ts:558-566

最终文件写入

6.2 脆弱代码

async function performSideEffects(
  outcome: MatchOutcome,
  codec: AnyCodec,
): Promise<void> {
  switch (outcome.type) {
    case 'missing-reference':
    case 'update-reference': {
      await writeScreenshot(
        outcome.reference.path,
        await encodeScreenshot(outcome.reference, codec),
      )
      break
    }

    case 'mismatch': {
      await writeScreenshot(
        outcome.actual.path,
        await encodeScreenshot(outcome.actual, codec),
      )

      if (outcome.diff) {
        await writeScreenshot(
          outcome.diff.path,
          await codec.encode(outcome.diff.image, {}),
        )
      }
      break
    }
  }
}

async function writeScreenshot(path: string, image: TypedArray) {
  try {
    await mkdir(dirname(path), { recursive: true })
    await writeFile(path, image)
  }
  catch (cause) {
    throw new Error('Couldn\'t write file to fs', { cause })
  }
}

6.3 为什么这条链容易被漏审

toMatchScreenshot() 看上去像一个“纯测试断言”能力,很多审计会把重点放在 page.screenshot() 这种显式文件操作上,而忽略 matcher 的副作用。

但从安全角度看,这里并不是“只在内存里比较图片”:

  • missing-reference 分支会写 reference 图
  • update-reference 分支会重写 reference 图
  • mismatch 分支会写 actual / diff 图

这意味着 matcher 实际上带着多个隐式写盘分支。

如果审计只检查“表面上接收 path 参数的 API”,这类 side-effect sink 很容易漏掉。

7. trace 链最复杂:同时包含写、删、外带

7.1 调用链

trace 相关逻辑不是单点 API,而是 Browser runner 在测试生命周期内自动触发:

图 7-1:trace 生命周期里同时存在写 trace、删 trace 和把 trace 作为 artifact 继续传递的三条分支。

关键符号如下:

符号

文件:行

作用

onAfterRetryTask

packages/browser/src/client/tester/runner.ts:119-151

触发 trace chunk 收尾

onAfterRunTask

packages/browser/src/client/tester/runner.ts:153-180

触发删除或 annotation

stopChunkTrace

packages/browser-playwright/src/commands/trace.ts:49-60

写 trace 文件

resolveTracesPath

packages/browser-playwright/src/commands/trace.ts:139-156

计算 trace 落盘路径

deleteTracing

packages/browser-playwright/src/commands/trace.ts:158-179

删除路径

annotateTraces

packages/browser-playwright/src/commands/trace.ts:181-209

把路径包装成 attachment

onTaskArtifactRecord

packages/browser/src/node/rpc.ts:197-215

Browser RPC artifact 入口

7.2 脆弱代码

function resolveTracesPath({ testPath, project }: BrowserCommandContext, name: string) {
  if (!testPath) {
    throw new Error(`This command can only be called inside a test file.`)
  }
  const options = project.config.browser!.trace
  const sanitizedName = `${project.name.replace(/[^a-z0-9]/gi, '-')}-${name}.trace.zip`
  if (options.tracesDir) {
    return resolve(options.tracesDir, sanitizedName)
  }
  const dir = dirname(testPath)
  const base = basename(testPath)
  return resolve(
    dir,
    '__traces__',
    base,
    `${project.name.replace(/[^a-z0-9]/gi, '-')}-${name}.trace.zip`,
  )
}

export const stopChunkTrace: BrowserCommand<[{ name: string }]> = async (
  context,
  { name },
) => {
  if (isPlaywrightProvider(context.provider)) {
    const path = resolveTracesPath(context, name)
    context.provider.pendingTraces.delete(path)
    await context.context.tracing.stopChunk({ path })
    return { tracePath: path }
  }
  throw new TypeError(`The ${context.provider.name} provider does not support tracing.`)
}

export const deleteTracing: BrowserCommand<[{ traces: string[] }]> = async (
  context,
  { traces },
) => {
  if (isPlaywrightProvider(context.provider)) {
    return Promise.all(
      traces.map(trace => unlink(trace).catch((err) => {
        if (err.code === 'ENOENT') {
          return
        }
        throw err
      })),
    )
  }
  throw new Error(`provider ${context.provider.name} is not supported`)
}

export const annotateTraces: BrowserCommand<[{ traces: string[]; testId: string }]> = async (
  { project },
  { testId, traces },
) => {
  const vitest = project.vitest
  await Promise.all(traces.map((trace) => {
    return vitest._testRun.recordArtifact(testId, {
      type: 'internal:annotation',
      annotation: {
        message: relative(project.config.root, trace),
        type: 'traces',
        attachment: {
          path: trace,
          contentType: 'application/octet-stream',
        },
      },
    })
  }))
}
// packages/browser/src/node/rpc.ts
async onTaskArtifactRecord(id, artifact) {
  if (!canWrite(project)) {
    if (artifact.type === 'internal:annotation' && artifact.annotation.attachment) {
      artifact.annotation.attachment = undefined
      vitest.logger.error(
        `[vitest] Cannot record annotation attachment because file writing is disabled. See https://vitest.dev/config/browser/api.`,
      )
    }
    if (artifact.attachments?.length) {
      const attachments = artifact.attachments.map(n => n.path).filter(r => !!r).join('", "')
      artifact.attachments = []
      vitest.logger.error(
        `[vitest] Cannot record attachments ("${attachments}") because file writing is disabled, removing attachments from artifact "${artifact.type}". See https://vitest.dev/config/browser/api.`,
      )
    }
  }

  return vitest._testRun.recordArtifact(id, artifact)
}

7.3 这条链比前两条更危险的原因

因为它同时包含三种原语:

  • stopChunkTrace:可写
  • deleteTracing:可删
  • annotateTraces:可外带

尤其是 annotateTraces(),它不会直接读取并返回内容,而是把路径写入 attachment.path,再交给 artifact 流程。

这意味着信息泄露未必发生在命令执行瞬间,而可能出现在后续 reporter / artifact copy 阶段。文件外带实际上是“延迟执行”的。

这种模式值得特别关注,因为很多现代工具链的泄露点都不在第一跳,而在后续收集、压缩、上传和报告流程里。

7.4 为什么说这是“延迟外带”模型

如果把 annotateTraces() 只看成一个普通命令,很容易低估它的危险性。更准确的执行过程是:

图 7-2:annotateTraces() 的危险点不在第一跳直接读文件,而在后续 artifact 流程里延迟触发文件复制或导出。

第一跳只是“声明一个本地路径值得被收集”,真正的文件访问可能发生在第二跳甚至第三跳。

这类漏洞的研究价值很高,因为它提醒你:

  • metadata 也是输入
  • attachment.path 也是文件系统入口
  • “不是现在读文件”不等于“后面不会读文件”

8. 统一看根因:为什么这是“权限模型断层”而不是单点路径遍历

如果把这个洞简单归类成 CWE-22 路径遍历,只说对了一部分。

更准确的根因拆解应该是:

  1. 浏览器侧可控路径越过 RPC 边界进入 Node/provider
  2. provider commands 各自实现文件操作,没有统一安全网关
  3. server.fs 限制没有在所有文件触达点执行
  4. allowWrite 限制没有在所有写入、删除触达点执行
  5. artifact attachment 路径在允许写分支下缺少进一步约束

所以这是一个典型的“局部做了安全控制,但架构没有强制所有路径复用”的问题。

只要安全控制不是 mandatory choke point,而只是“建议各命令自己调用”,最终就一定会长出旁路。

9. 补丁分析:修复的核心是把安全检查从分散变成统一

主修复提交:

33f96a145ef09ca6a43b4e555eb273e64a87be23

从提交规模看,这也不是一次“顺手补个 if”的小修。主修复提交一共修改了 245 行,范围覆盖 provider command、Browser RPC、公用 utils 和回归测试。这个信息本身就说明,维护者已经把它当成架构层缺陷,而不是单一 API 漏检。

这次修复最关键的变化,是新增两个统一检查函数:

export function slash(path: string): string {
  return path.replace(/\\/g, '/').replace(/\/+/g, '/')
}

export function assertBrowserFileAccess(project: TestProject, path: string): void {
  const normalized = slash(path)
  if (
    !isFileLoadingAllowed(project.vite.config, normalized)
    && !isFileLoadingAllowed(project.vitest.vite.config, normalized)
  ) {
    throw new Error(
      `Access denied to "${path}". See Vite config documentation for "server.fs": https://vitejs.dev/config/server-options.html#server-fs-strict.`,
    )
  }
}

export function assertBrowserApiWrite(project: TestProject, path: string): void {
  if (!project.config.browser.api.allowWrite || !project.vitest.config.api.allowWrite) {
    throw new Error(
      `Cannot modify file "${path}". File writing is disabled because the server is exposed to the internet, see https://vitest.dev/config/browser/api.`,
    )
  }
}

这两个函数分别对应两道真正该存在的闸门:

  • assertBrowserFileAccess(...)
  • 负责路径边界
  • 复用 Vite server.fs 语义
  • 拒绝越界路径和 deny-list 路径
  • assertBrowserApiWrite(...)
  • 负责写权限策略
  • 在 Browser API 暴露场景下执行写入/删除阻断

9.1 upload 的修复

修复前:

if (typeof file === 'string') {
  return resolve(root, file)
}

修复后:

if (typeof file === 'string') {
  const filepath = resolve(root, file)
  assertBrowserFileAccess(context.project, filepath)
  return filepath
}

关键点是:读取链不需要 allowWrite,但必须过 server.fs 边界。

9.2 takeScreenshot 的修复

修复前:

if (options.save) {
  savePath = normalize(path)
  await mkdir(dirname(savePath), { recursive: true })
}

修复后:

if (options.save) {
  savePath = normalize(path)

  assertBrowserApiWrite(context.project, savePath)
  assertBrowserFileAccess(context.project, savePath)

  await mkdir(dirname(savePath), { recursive: true })
}

关键点是:写盘前同时检查“允不允许写”和“允不允许访问这个路径”。

9.3 trace 链的修复

trace 相关修复最说明问题,因为它覆盖了三种动作:

  • stopChunkTrace 写 trace 前加 assertBrowserApiWrite + assertBrowserFileAccess
  • deleteTracing 删除前对每个 trace 路径加同样检查
  • annotateTraces 记录 artifact 前也加同样检查

这说明维护者已经把问题认识成“凡是命令触碰文件系统,都必须统一过闸”,而不是“只修一两个高曝光 API”。

直接看修复后的关键片段更清楚:

export const stopChunkTrace: BrowserCommand<[{ name: string }]> = async (
  context,
  { name },
) => {
  if (isPlaywrightProvider(context.provider)) {
    const path = resolveTracesPath(context, name)
    assertBrowserApiWrite(context.project, path)
    assertBrowserFileAccess(context.project, path)
    context.provider.pendingTraces.delete(path)
    await context.context.tracing.stopChunk({ path })
    return { tracePath: path }
  }
}

export const deleteTracing: BrowserCommand<[{ traces: string[] }]> = async (
  context,
  { traces },
) => {
  if (isPlaywrightProvider(context.provider)) {
    for (const trace of traces) {
      assertBrowserApiWrite(context.project, trace)
      assertBrowserFileAccess(context.project, trace)
    }
    return Promise.all(traces.map(trace => unlink(trace).catch(/* ... */)))
  }
}

export const annotateTraces: BrowserCommand<[{ traces: string[]; testId: string }]> = async (
  { project },
  { testId, traces },
) => {
  await Promise.all(traces.map((trace) => {
    assertBrowserApiWrite(project, trace)
    assertBrowserFileAccess(project, trace)
    return vitest._testRun.recordArtifact(testId, {
      type: 'internal:annotation',
      annotation: {
        attachment: {
          path: trace,
          contentType: 'application/octet-stream',
        },
      },
    })
  }))
}

9.4 screenshotMatcher 的修复

修复前:

async function writeScreenshot(path: string, image: TypedArray) {
  await mkdir(dirname(path), { recursive: true })
  await writeFile(path, image)
}

修复后:

async function performSideEffects(
  outcome: MatchOutcome,
  codec: AnyCodec,
  project: TestProject,
): Promise<void> {
  switch (outcome.type) {
    case 'missing-reference':
    case 'update-reference':
      await writeScreenshot(
        outcome.reference.path,
        await encodeScreenshot(outcome.reference, codec),
        project,
      )
      break

    case 'mismatch':
      await writeScreenshot(
        outcome.actual.path,
        await encodeScreenshot(outcome.actual, codec),
        project,
      )
      if (outcome.diff) {
        await writeScreenshot(
          outcome.diff.path,
          await codec.encode(outcome.diff.image, {}),
          project,
        )
      }
      break
  }
}

async function writeScreenshot(path: string, image: TypedArray, project: TestProject) {
  assertBrowserApiWrite(project, path)
  assertBrowserFileAccess(project, path)
  await mkdir(dirname(path), { recursive: true })
  await writeFile(path, image)
}

这里的价值在于,连 matcher 这种“容易被当内部逻辑”的 side effect 也被纳入统一防线。

9.5 artifact 路径的修复

rpc.ts 里修复前的 artifact 处理逻辑,只会在 !canWrite(project) 时移除 attachment,但对允许写的分支没有继续校验路径。

修复后,attachment path 在允许分支里也会被检查。这个变化很关键,因为它阻断的是“借报告链路外带本地文件”的后半段。

修复后的 rpc.ts 关键上下文如下:

async onTaskArtifactRecord(id, artifact) {
  if (!canWrite(project)) {
    // 省略:禁写时移除 attachment / attachments
  }
  else {
    const attachments = artifact.type === 'internal:annotation'
      ? (artifact.annotation.attachment ? [artifact.annotation.attachment] : [])
      : (artifact.attachments ?? [])

    for (const attachment of attachments) {
      const path = attachment.path
      if (path && !path.startsWith('http://') && !path.startsWith('https://')) {
        checkFileAccess(resolve(project.config.root, path))
      }
    }
  }

  return vitest._testRun.recordArtifact(id, artifact)
}

9.6 这次补丁真正建立了什么安全不变量

如果只把这次修复理解成“多加了几个检查函数”,还是不够深入。

它真正建立的是下面四条安全不变量:

  1. 凡是浏览器侧传进来的文件路径,只要会落到宿主机文件系统,必须统一经过 assertBrowserFileAccess(...)。
  2. 凡是会写、删、覆盖、复制本地文件的动作,必须统一经过 assertBrowserApiWrite(...)。
  3. artifact attachment 不是普通元数据,而是另一种文件路径输入,也必须按文件访问处理。
  4. 安全校验必须贴近 sink 执行,而不是只放在更高层的 API 或配置层。

这就是为什么这次修复比“拦某个 payload”更有价值。它修的是安全模型,而不是修某一个路径字符串。

9.7 回归测试证据:权限契约已经被编码

这次补丁还新增了几组很有代表性的回归测试:

  • command-permissions-upload-denied
  • command-permissions-screenshot-denied
  • command-permissions-screenshot-no-write

这些测试对应的不是功能正确性,而是权限契约。从上游 errors.test.ts 的断言看,修复后的预期行为已经被编码成明确错误:

  • Access denied to "<root>/my-secret.txt"
  • Access denied to "<root>/my-secret.png"
  • Cannot modify file "<root>/out.png"

这类测试的意义在于:以后就算有人重构 provider 命令,只要又把某条路径绕开了统一闸门,测试就会第一时间炸掉。

9.8 补丁完整性审计:覆盖范围与剩余风险

这里最关键的问题不是“有没有补丁”,而是“补丁是否已经把这类问题整体收口”。

基于本文本地 CodeQL 结果、人工复核的调用链,以及主修复提交本身,可以得出三个层次的结论:

  1. 在本次 CVE 已公开的文件触达面内,主线补丁覆盖是比较完整的。
    upload、takeScreenshot、screenshotMatcher、stopChunkTrace、deleteTracing、annotateTraces、artifact attachment 处理都已经被纳入统一闸门。
  2. 补丁不只是修 provider 命令,还补到了 RPC artifact 入口。
    这很关键,因为否则 annotateTraces 这类“第一跳只写 metadata、第二跳才读文件”的路径仍可能残留旁路。
  3. 这次修复仍然不是 capability-based 设计。
    它已经把 mandatory gate 做强了,但未来如果新增命令绕开 assertBrowserFileAccess(...) / assertBrowserApiWrite(...),同类问题仍可能复发。

可以把这次修复理解为从“局部补洞”提升到“统一守门”,但还没有进化到“默认无权限、只能通过能力对象显式申请文件操作”的更强模型。

9.9 分支回补差异本身也说明攻击面并不完全一致

主线修复之后,又分别回补到 v4 和 v3。这点不只是版本维护信息,还能反向说明各分支的实际攻击面不完全相同。

从本地底稿整理的 PR 信息看,v3 回补重点是当时分支里实际存在的 upload、screenshot、onTaskAnnotate 等路径,而不是机械地把主线所有代码原样搬回去。

这说明两件事:

  • 同一个 CVE 在不同大版本上的“具体攻击面”可能略有差异。
  • 做补丁完整性评估时,不能只看 GHSA 标题,还要看分支里实际存在哪些命令和 sink。

10. 本地复现:脆弱版与修复版对照验证

为了避免宿主机 Node、浏览器依赖、Playwright 运行时差异干扰结果,测试执行统一放在 Docker 容器内完成,宿主机只负责提供 Docker 和挂载输出目录。

这套实验只验证两条最关键、也最容易稳定复现的原语:

  1. userEvent.upload(input, 'secret.txt') 是否能绕过 server.fs.deny
  2. page.screenshot({ path: '/app/repro-output/out.png' }) 是否能绕过 allowWrite: false

10.1 先把实验骨架钉死:两个版本、同一套容器入口

整个实验只做一件事:让脆弱版和修复版跑完全相同的测试思路,只改 Vitest 版本,看行为是否翻转。

两个服务的切换入口就在 docker-compose.yml:

services:
  vulnerable:
    build:
      context: .
      args:
        VITEST_VERSION: 4.1.9
        PLAYWRIGHT_VERSION: 1.54.0
    environment:
      TARGET_TEST: tests/vulnerable.test.js
      REPORT_FILE: /app/repro-output/report.txt
    volumes:
      - ./repro-output/vulnerable:/app/repro-output

  fixed:
    build:
      context: .
      args:
        VITEST_VERSION: 4.1.10
        PLAYWRIGHT_VERSION: 1.54.0
    environment:
      TARGET_TEST: tests/fixed.test.js
      REPORT_FILE: /app/repro-output/report.txt
    volumes:
      - ./repro-output/fixed:/app/repro-output

镜像本身也没有隐藏逻辑,关键就是把 Browser Mode 运行环境固定在容器里,并通过构建参数切换依赖版本:

FROM node:20-bookworm

WORKDIR /app

COPY vitest.config.mjs /app/vitest.config.mjs
COPY secret.txt /app/secret.txt
COPY entrypoint.sh /app/entrypoint.sh
COPY tests /app/tests

ARG VITEST_VERSION=4.1.9
ARG PLAYWRIGHT_VERSION=1.54.0

RUN corepack enable \
 && corepack prepare pnpm@9.15.9 --activate \
 && pnpm add -D "vitest@${VITEST_VERSION}" "@vitest/browser@${VITEST_VERSION}" "@vitest/browser-playwright@${VITEST_VERSION}" "playwright@${PLAYWRIGHT_VERSION}" \
 && pnpm exec playwright install --with-deps chromium

被读取的目标文件也非常简单,secret.txt 只有一行内容:

TOP_SECRET_DO_NOT_READ

这样一来,读取链是否打穿就不需要复杂判断:

  • 如果 upload() 被拒绝,说明 server.fs 闸门还在
  • 如果页面最终读到 TOP_SECRET_DO_NOT_READ,说明 provider 命令已经绕过了这层闸门

同理,/app/repro-output/out.png 的存在与否,也能直接说明 allowWrite: false 到底有没有被真正尊重。

真正决定实验成败的是 Browser Mode 配置本身。本文复现固定了一个明确的“应拒绝”基线:

import { playwright } from '@vitest/browser-playwright'
import { defineConfig } from 'vitest/config'

export default defineConfig({
  server: {
    fs: {
      deny: ['secret.txt'],
    },
  },
  test: {
    browser: {
      enabled: true,
      provider: playwright(),
      headless: true,
      screenshotFailures: false,
      api: {
        host: '0.0.0.0',
        port: 63315,
        strictPort: true,
        allowExec: false,
        allowWrite: false,
      },
      instances: [
        {
          browser: 'chromium',
        },
      ],
    },
  },
})

这里有两个故意设下的安全断言:

  1. server.fs.deny = ['secret.txt'],按理说浏览器侧不应读到这个文件
  2. browser.api.allowWrite = false,按理说浏览器侧不应写出截图文件

后面的所有复现步骤,本质上都是在验证这两条策略到底有没有被底层 command 真正执行。

10.2 先把脆弱版测试写清楚:两条链怎么被触发

脆弱版测试并不复杂,第一段直接验证 upload() 读取链:

test('reads a denied file through upload()', async () => {
  document.body.innerHTML = `
    <main>
      <input id="upload-target" type="file" />
      <pre id="leak-output">Waiting for upload()...</pre>
    </main>
  `

  const input = document.querySelector('#upload-target')
  const output = document.querySelector('#leak-output')

  await userEvent.upload(input, 'secret.txt')

  const leaked = await input.files[0].text()
  output.textContent = `LEAKED_SECRET:${leaked}`
  console.log(`LEAKED_SECRET:${leaked}`)
  await page.screenshot({ path: '/app/repro-output/browser-upload-leak.png' })
  expect(leaked).toContain('TOP_SECRET_DO_NOT_READ')
})

这里最关键的动作只有三步:

  1. 浏览器侧把字符串路径 secret.txt 送进 userEvent.upload()
  2. 如果 provider 没有尊重 server.fs.deny,input.files[0] 就会拿到真实宿主文件
  3. 测试再调用 text() 把内容读回浏览器上下文,并打印 LEAKED_SECRET:...

第二段测试直接验证截图写入链:

test('writes a screenshot even when browser.api.allowWrite is false', async () => {
  document.body.innerHTML = `
    <main>
      <section>
        <h1>Screenshot write bypass</h1>
        <p>This page is being saved to <code>/app/repro-output/out.png</code> even though <code>allowWrite</code> is disabled.</p>
      </section>
    </main>
  `

  await page.screenshot({ path: '/app/repro-output/out.png' })
  expect(true).toBe(true)
})

这里故意把路径写成容器内绝对路径 /app/repro-output/out.png,原因很直接:这样一旦漏洞存在,产物就会稳定落到挂载目录,而不是被相对路径解析行为干扰。

10.3 容器内环境确认

进入脆弱版容器后,先确认运行时版本和工作目录,确保测试是在容器内 /app 目录执行,而不是误落到宿主机环境。

node -v
pnpm -v
pnpm exec playwright --version
ls -1

图 10-1:脆弱版容器内的 Node、pnpm、Playwright 版本和 /app 工作目录内容。

环境要点如下:

  • 容器基线是 node:20-bookworm
  • Playwright 版本固定为 1.54.0
  • 测试、配置、秘密文件都直接位于 /app 下,路径关系非常简单,不存在“跑错目录才触发”的偶然因素

10.4 脆弱版:执行入口和结果如何对应

宿主机侧并没有额外魔法,entrypoint.sh 只是把测试目标和日志输出路径接起来:

#!/usr/bin/env bash
set -euo pipefail

TARGET_TEST="${TARGET_TEST:-tests/vulnerable.test.js}"
REPORT_FILE="${REPORT_FILE:-/app/repro-output/report.txt}"

mkdir -p /app/repro-output
rm -f /app/repro-output/out.png "$REPORT_FILE"

/app/node_modules/.bin/vitest run --config /app/vitest.config.mjs "$TARGET_TEST" --reporter=verbose | tee "$REPORT_FILE"

脆弱版的一键入口也同样很短:

#!/usr/bin/env bash
set -euo pipefail

mkdir -p "${ROOT_DIR}/repro-output/vulnerable"
rm -f "${ROOT_DIR}/repro-output/vulnerable/out.png" "${ROOT_DIR}/repro-output/vulnerable/report.txt"

docker compose -f "${ROOT_DIR}/docker-compose.yml" run --build --rm vulnerable

test -f "${ROOT_DIR}/repro-output/vulnerable/out.png"

换句话说,宿主机真正执行的核心动作就是:

docker compose -f docker-compose.yml run --build --rm vulnerable

容器内部再展开成:

TARGET_TEST=tests/vulnerable.test.js REPORT_FILE=/app/repro-output/report.txt /app/entrypoint.sh
ls -l /app/repro-output

图 10-2:脆弱版 vitest@4.1.9 在容器内执行后的终端输出。日志里已经出现 LEAKED_SECRET,同时目录中出现了额外 PNG 产物。

这张图同时证明了两件事:

  1. LEAKED_SECRET:TOP_SECRET_DO_NOT_READ 已经说明 userEvent.upload() 成功把本应被拒绝的 /app/secret.txt 交给了浏览器侧 <input type="file">
  2. /app/repro-output/ 下同时出现 browser-upload-leak.png 和 out.png,说明浏览器侧传入的截图路径最终落到了宿主文件系统

为了让“读取面成功”不只停留在终端日志里,测试在读出文件内容后,会把结果直接渲染到页面,再由 Browser Mode 生成页面截图。

图 10-3:浏览器页上的 <input type="file"> 已经拿到了 secret.txt,并把泄露内容直接显示在页面上。

同样地,截图写入链也不只是“目录里多了一个文件”这么抽象。待截图页面本身包含说明文字,因此生成的 out.png 可以直接作为漏洞证据。

图 10-4:page.screenshot({ path: '/app/repro-output/out.png' }) 成功把页面落盘到文件系统,说明 allowWrite: false 在脆弱版中没有被真正执行。

从复现角度看,脆弱版最重要的判断标准就是下面这组三连:

  • 报告文件里出现 LEAKED_SECRET:TOP_SECRET_DO_NOT_READ
  • 浏览器页截图 browser-upload-leak.png 明确展示泄露内容已经回流到浏览器上下文
  • 输出目录中出现 out.png

只要这三条同时成立,就可以确认“读”和“写”两条链都已经打穿。

10.5 修复版:同样的输入为什么会翻转成拒绝

修复版不改实验思路,只改版本和断言。对应测试代码如下:

test('blocks upload() access to denied files after the patch', async () => {
  document.body.innerHTML = `
    <main>
      <input id="upload-target" type="file" />
    </main>
  `

  const input = document.querySelector('#upload-target')
  const error = await userEvent.upload(input, 'secret.txt').then(() => null, err => err)

  console.log(`UPLOAD_BLOCKED:${error?.message ?? 'missing error'}`)
  expect(error).toBeTruthy()
  expect(error.message).toMatch(/Access denied/i)
})

test('blocks screenshot writes when browser.api.allowWrite is false after the patch', async () => {
  const error = await page.screenshot({ path: '/app/repro-output/out.png' }).then(() => null, err => err)

  console.log(`SCREENSHOT_BLOCKED:${error?.message ?? 'missing error'}`)
  expect(error).toBeTruthy()
  expect(error.message).toMatch(/Cannot modify file/i)
})

宿主机侧的修复版入口也只做一件事:运行 fixed 服务后,确认 out.png 没有生成。

#!/usr/bin/env bash
set -euo pipefail

mkdir -p "${ROOT_DIR}/repro-output/fixed"
rm -f "${ROOT_DIR}/repro-output/fixed/out.png" "${ROOT_DIR}/repro-output/fixed/report.txt"

docker compose -f "${ROOT_DIR}/docker-compose.yml" run --build --rm fixed

if [[ -f "${ROOT_DIR}/repro-output/fixed/out.png" ]]; then
  echo "fixed verification failed: screenshot artifact should not exist" >&2
  exit 1
fi

修复版保持相同测试意图,只把版本切换到 vitest@4.1.10,然后继续在容器里执行同样结构的命令:

TARGET_TEST=tests/fixed.test.js REPORT_FILE=/app/repro-output/report.txt /app/entrypoint.sh
ls -l /app/repro-output

图 10-5:修复版 vitest@4.1.10 在容器内执行后的终端输出。两条危险操作都被明确拒绝,且目录里不再生成 out.png。

修复版这张图比“测试通过”更有价值的地方,在于它把两道拦截都展示成了可读错误:

  • UPLOAD_BLOCKED:Access denied to "/app/secret.txt"...
  • SCREENSHOT_BLOCKED:Cannot modify file "/app/repro-output/out.png"...

这正好对应补丁中新引入的两类统一检查:

  • assertBrowserFileAccess(...) 负责把 upload() 的文件读取重新拉回 server.fs 约束
  • assertBrowserApiWrite(...) 负责把 page.screenshot() 的写文件动作重新拉回 allowWrite 约束

修复版并不是“看起来没有复现”,而是以明确错误的形式证明了两个安全闸门已经重新生效。

10.6 结果和漏洞原语的对应关系

为了避免把“看到了几张图”误解成“已经证明所有变种都能利用”,下面把本地证据和它们各自能证明的范围对应起来:

本地证据

证明的能力

不能单独证明什么

LEAKED_SECRET:TOP_SECRET_DO_NOT_READ

upload() 读取链可绕过 server.fs.deny

不能单独推出所有 provider 都存在相同读取面

browser-upload-leak.png

泄露内容已经回流到浏览器上下文,可被测试代码直接读取

不能单独推出远程攻击者一定能直接打到该链

out.png 存在

page.screenshot() 写盘链可绕过 allowWrite: false

不能单独推出任意字节内容写入

修复版 Access denied / Cannot modify file

补丁把读取和写入两类路径重新纳入统一闸门

不能单独证明 trace / annotation 等所有其他链都被完全消灭

这组 Docker 复现的意义,不是穷尽所有 provider 和所有命令,而是用最短路径确认这次 CVE 的两个核心安全结论:

  1. 修复前,Browser Mode 内建命令确实能绕过策略层读写本地文件
  2. 修复后,这两条最关键的文件触达路径已经重新受到统一安全检查约束

11. 失败边界与不可利用条件:这个洞明确“做不到什么”

如果一篇漏洞分析只写“能做什么”,很容易把读者带向过度推断。这个 CVE 至少存在几条明确边界:

  1. 它不等价于“任意内容写入”。
    takeScreenshot 和 screenshotMatcher 写出去的是 PNG / diff / reference 图,stopChunkTrace 写出去的是 trace 压缩包。攻击者通常能控制写到哪里,但不能像模板注入那样直接把任意 payload 字节写进目标文件。
  2. 本文没有证明该 CVE 单独即可稳定达到 RCE。
    读取敏感文件、覆盖产物、删除文件、通过 artifact 外带,这些影响已经足够严重;但“仅凭这一个漏洞直接拿到代码执行”并不是本文已验证结论。
  3. 不是所有路径都具备同样强的路径自由度。
    page.screenshot({ path }) 这类接口的路径控制最直接;screenshotMatcher 则往往还受 reference / actual / diff 命名规则影响,虽然写盘面真实存在,但它的路径塑形未必像显式 screenshot API 那么自由。
  4. 读取能否成功仍受 OS 权限约束。
    这个漏洞绕过的是 Vitest / Vite 的逻辑边界,不会绕过操作系统本身的文件权限模型。Node 进程读不到的文件,Browser API 也读不到。
  5. 默认 localhost 且测试代码可信的环境,远程利用条件并不天然满足。
    在这种场景里,它更像“隔离假设失效”而不是“互联网暴露即刻被打”的问题。

把这些边界写清楚,文章会更像技术研究,而不是把所有危险后果都一股脑外推。

11.1 但哪些高阶后果仍然值得警惕

虽然本文没有把它直接链到 RCE,但下面这些后果在真实工程环境里已经足够严重:

  • 读取 .env、token、云凭证、SSH key、CI secret 等本地敏感文件
  • 覆盖 screenshot / snapshot / trace / 测试产物,造成污染或误导
  • 删除已有本地文件,破坏构建或测试状态
  • 通过 trace attachment / artifact 流程把本地文件带出到报告、CI artifact 或调试产物中

也就是说,这个漏洞最稳定的价值并不是“马上执行命令”,而是打穿原本被认为存在的本地文件访问边界。

12. 把它放回 Vitest Browser Mode 的漏洞谱系里看

单看 CVE-2026-73653,很容易把它理解成一个独立的 provider 权限绕过问题;但如果和 Vitest 近两年的 Browser Mode / API 漏洞放在一起看,会发现它属于同一类设计主题的重复暴露:

编号

披露日期

核心问题

共性

CVE-2025-24963

2025-02-04

Browser Mode HTTP handler 任意文件读取

服务端把本地文件能力暴露给了不该信任的边界

CVE-2025-24964

2025-02-04

Vitest API 缺少 Origin 校验导致 CSWSH / RCE

高权限 API 对低信任来源暴露

CVE-2026-53633

2026-06-01

Browser Mode CDP 桥绕过 allowWrite/allowExec

已定义的权限模型没有覆盖所有高权限通道

CVE-2026-73653

2026-07-08

provider commands 绕过文件访问闸门

Browser RPC 到 provider 的多条文件链缺少统一 mandatory gate

把这几次问题连起来看,真正值得记住的不是某个具体 payload,而是一种反复出现的设计模式:

只要 Browser Mode 里存在“浏览器端可达、Node 端高权限执行”的桥,就必须默认按低信任边界设计,而不能按“开发调试工具天然可信”设计。

13. 对审计与防守工作的直接启发

这个漏洞留下的最直接经验,不是某个具体 API 名,而是一套审计方法。

以后看到下面这种产品结构,应该默认高优先级检查:

  1. 浏览器端、前端或客户端能传文件路径
  2. 服务端 provider / plugin / helper 代表客户端访问宿主文件系统
  3. 产品里存在不止一条文件触达路径
  4. 某些路径复用了安全检查,某些路径没有

具体到代码层面,可以优先搜:

  • triggerCommand
  • resolve
  • normalize
  • mkdir
  • writeFile
  • unlink
  • setInputFiles
  • recordArtifact
  • attachment.path

然后问一个最核心的问题:

这些 sink 前面,是否都经过了同一个 mandatory 安全检查函数。

如果答案是否定的,通常就值得继续挖。

14. 结论

CVE-2026-73653 的价值不只在于它能读写删文件,更在于它清楚展示了现代工具链里一种高频失误:

产品已经定义了权限模型,但没有把所有高权限命令都强制收口到同一个检查点。

一旦浏览器输入可以跨过 RPC 边界进入 Node/provider,任何遗漏掉安全检查的命令,都会变成一条独立的利用链。

这也是为什么这次修复的真正重点,不是封某个特殊 payload,而是把所有文件系统接触点统一收敛到:

  • assertBrowserFileAccess(...)
  • assertBrowserApiWrite(...)

从漏洞研究角度看,这比单个 API 的细节更重要,因为它直接告诉你下次该去哪里找同类问题。

15. 参考资料

  1. NVD: https://nvd.nist.gov/vuln/detail/CVE-2026-73653
  2. GitHub Security Advisory: https://github.com/vitest-dev/vitest/security/advisories/GHSA-p63j-vcc4-9vmv
  3. 主修复提交: https://github.com/vitest-dev/vitest/commit/33f96a145ef09ca6a43b4e555eb273e64a87be23
  4. 修复 PR: https://github.com/vitest-dev/vitest/pull/10674
  5. v4 回补提交: https://github.com/vitest-dev/vitest/commit/5c18dd267ff7f47f24cab2f615a16b37d90feb7f
  6. v3 回补提交: https://github.com/vitest-dev/vitest/commit/b795e36b34969bec50b47a9f29d26f799a6a04fb