自定义 ClassLoader 缺失 Sealed Package 校验导致包内类型注入
自定义 ClassLoader 读取 JAR 字节并直接调用 defineClass 时,JAR Manifest 中的 sealed package 约束可能不会生效。封闭包一旦在运行时被定义成普通包,外部 JAR 中的同包名类就可能进入同一个运行时包,并访问包级私有成员。
自定义
ClassLoader读取 JAR 字节并直接调用defineClass时,JAR Manifest 中的 sealed package 约束可能不会生效。封闭包一旦在运行时被定义成普通包,外部 JAR 中的同包名类就可能进入同一个运行时包,并访问包级私有成员。
01|封闭包的边界假设
JAR Manifest 支持通过 Sealed: true 将包绑定到单一代码来源。包被封闭后,同一包名下的类只能继续从相同来源加载。这里的 sealed package 属于 JAR 与类加载阶段的约束,不是 Java 语言层面的 sealed class。
插件加载器、热更新加载器、脚本桥接加载器、内存字节码加载器经常会自行读取 .class 字节,再调用 defineClass 完成类定义。如果加载器没有读取 Manifest,也没有在定义类前调用带封闭来源的 definePackage,JAR 中声明的封闭包会在运行时退化为普通包。
退化后的直接后果是:外部构造的同包名类型可被同一个自定义加载器定义到目标包内,从而访问包级私有类、方法或字段。
02|底层原理:运行时包的双重身份
Java 包级访问控制不只比较包名,还比较定义类加载器。运行时包由两个条件共同决定:
运行时包 = package name + defining ClassLoader两个类满足以下条件时,包级私有访问可以通过:
1. package name 完全相同
2. defining ClassLoader 是同一个对象JAR sealed package 的约束依赖 Package 元数据。标准加载器处理封闭包时,会先读取 Manifest,再根据 Sealed 属性定义或校验包,最后才调用 defineClass:
读取 JAR Manifest
解析 Sealed 属性
调用 definePackage(packageName, ..., sealBase)
调用 defineClass(className, bytes, ...)Manifest 主属性可写成:
Manifest-Version: 1.0
Sealed: true包条目属性也可单独声明:
Manifest-Version: 1.0
Name: com/acme/sealed/
Sealed: true主属性中的 Sealed: true 表示 JAR 内所有包默认封闭。包条目属性优先级更高,可覆盖主属性。
URLClassLoader 会维护该语义。自定义加载器若只执行 defineClass,类定义动作本身不会自动读取 Manifest,也不会自动补充 sealed package 校验。
03|实验构造:三种来源与三条加载路径
构造三个 JAR 来源:
app-sealed.jar:包含封闭包com.acme.sealed,内部有包级私有类PackageSecret。injected.jar:包含同包名类Injected,尝试访问PackageSecret.read()。merged-sealed.jar:将核心类与注入类放入同一个封闭 JAR,用来验证 sealed package 限制的是来源一致性,而不是禁止同包类共存。
加载侧包含三条路径:
URLClassLoader:JDK 标准加载器,保留 Manifest sealed package 语义。LooseJarLoader:存在缺陷的自定义加载器,只创建未封闭包并调用defineClass。FixedJarLoader:修复后的自定义加载器,在defineClass前执行 sealed package 校验。
03.1|JDK 工具状态
java -version
javac -version
jar --version
03.2|源码与产物布局

src-app/ 核心包源码
src-inject/ 外部同包名类源码
src-runner/ 加载器与运行入口
manifest/ JAR Manifest
build/ 编译产物与 JAR03.3|核心包:包级私有目标
文件:src-app/com/acme/sealed/PackageSecret.java
cat > src-app/com/acme/sealed/PackageSecret.java <<'EOF'
package com.acme.sealed;
final class PackageSecret {
static String read() {
return "internal-token-from-package-private-method";
}
}
EOF文件:src-app/com/acme/sealed/Gate.java
cat > src-app/com/acme/sealed/Gate.java <<'EOF'
package com.acme.sealed;
public final class Gate {
public static String publicCall() {
return "Gate=" + PackageSecret.read();
}
}
EOF文件 src-app/com/acme/sealed/PackageSecret.java 中,PackageSecret 与 read() 都没有 public 修饰符。包外代码不能通过普通 Java 调用直接访问该方法。
03.4|注入类:同包名直接调用
文件:src-inject/com/acme/sealed/Injected.java
cat > src-inject/com/acme/sealed/Injected.java <<'EOF'
package com.acme.sealed;
public final class Injected {
public static String steal() {
return "Injected=" + PackageSecret.read();
}
}
EOF该调用不使用反射,不使用 setAccessible(true),也不依赖命令行开放模块访问。运行时能否成功,只取决于类加载后的运行时包判断。
03.5|Manifest:绑定封闭来源
文件:manifest/MANIFEST.MF
cat > manifest/MANIFEST.MF <<'EOF'
Manifest-Version: 1.0
Sealed: true
EOFManifest 末尾保留空行,避免主属性段被错误解析。
03.6|JAR 读取工具
文件:src-runner/JarSupport.java
cat > src-runner/JarSupport.java <<'EOF'
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Path;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.Manifest;
final class JarSupport {
private JarSupport() {
}
static Manifest readManifest(Path jar) throws IOException {
try (JarFile jarFile = new JarFile(jar.toFile())) {
return jarFile.getManifest();
}
}
static byte[] readClassBytes(Path jar, String entryName) throws IOException {
try (JarFile jarFile = new JarFile(jar.toFile())) {
JarEntry entry = jarFile.getJarEntry(entryName);
if (entry == null) {
return null;
}
try (InputStream in = jarFile.getInputStream(entry)) {
return readAll(in);
}
}
}
private static byte[] readAll(InputStream in) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
byte[] buffer = new byte[8192];
while (true) {
int n = in.read(buffer);
if (n < 0) {
break;
}
out.write(buffer, 0, n);
}
return out.toByteArray();
}
}
EOF03.7|缺陷加载器:封闭语义丢失
文件:src-runner/LooseJarLoader.java
cat > src-runner/LooseJarLoader.java <<'EOF'
import java.io.IOException;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.List;
final class LooseJarLoader extends ClassLoader {
private final List<Path> jars;
LooseJarLoader(Path... jars) {
super(null);
this.jars = Arrays.asList(jars);
}
@Override
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
Class<?> loaded = findLoadedClass(name);
if (loaded == null) {
if (name.startsWith("com.acme.sealed.")) {
try {
loaded = findClass(name);
} catch (ClassNotFoundException ignored) {
}
}
if (loaded == null) {
loaded = super.loadClass(name, false);
}
}
if (resolve) {
resolveClass(loaded);
}
return loaded;
}
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
String entry = name.replace('.', '/') + ".class";
for (Path jar : jars) {
try {
byte[] bytes = JarSupport.readClassBytes(jar, entry);
if (bytes != null) {
// 缺陷点:Manifest 中的 Sealed 属性没有进入 Package 元数据。
defineUnsealedPackageIfAbsent(name);
return defineClass(name, bytes, 0, bytes.length);
}
} catch (IOException e) {
throw new ClassNotFoundException(name, e);
}
}
throw new ClassNotFoundException(name);
}
private void defineUnsealedPackageIfAbsent(String className) {
int pos = className.lastIndexOf('.');
if (pos < 0) {
return;
}
String pkgName = className.substring(0, pos);
if (getDefinedPackage(pkgName) == null) {
// 最后一个参数为 null,表示运行时包未封闭。
definePackage(pkgName, null, null, null, null, null, null, null);
}
}
}
EOF03.8|修复加载器:来源一致性校验
文件:src-runner/FixedJarLoader.java
cat > src-runner/FixedJarLoader.java <<'EOF'
import java.io.IOException;
import java.net.URL;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.List;
import java.util.jar.Attributes;
import java.util.jar.Manifest;
final class FixedJarLoader extends ClassLoader {
private final List<Path> jars;
FixedJarLoader(Path... jars) {
super(null);
this.jars = Arrays.asList(jars);
}
@Override
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
Class<?> loaded = findLoadedClass(name);
if (loaded == null) {
if (name.startsWith("com.acme.sealed.")) {
try {
loaded = findClass(name);
} catch (ClassNotFoundException ignored) {
}
}
if (loaded == null) {
loaded = super.loadClass(name, false);
}
}
if (resolve) {
resolveClass(loaded);
}
return loaded;
}
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
String entry = name.replace('.', '/') + ".class";
for (Path jar : jars) {
try {
byte[] bytes = JarSupport.readClassBytes(jar, entry);
if (bytes != null) {
Manifest manifest = JarSupport.readManifest(jar);
// 修复点:定义类之前先定义或校验 Package。
defineOrCheckPackage(name, jar, manifest);
return defineClass(name, bytes, 0, bytes.length);
}
} catch (IOException e) {
throw new ClassNotFoundException(name, e);
}
}
throw new ClassNotFoundException(name);
}
private void defineOrCheckPackage(String className, Path jar, Manifest manifest) throws IOException {
int pos = className.lastIndexOf('.');
if (pos < 0) {
return;
}
String pkgName = className.substring(0, pos);
URL sealBase = jar.toUri().toURL();
boolean sealedByManifest = isSealedByManifest(className, manifest);
Package existing = getDefinedPackage(pkgName);
if (existing == null) {
// sealedByManifest 为 true 时,将包绑定到当前 JAR URL。
definePackage(pkgName, null, null, null, null, null, null,
sealedByManifest ? sealBase : null);
return;
}
if (existing.isSealed() && !existing.isSealed(sealBase)) {
throw new SecurityException("sealing violation: package " + pkgName + " is sealed");
}
if (!existing.isSealed() && sealedByManifest) {
throw new SecurityException("sealing violation: package " + pkgName + " was already loaded as unsealed");
}
}
private static boolean isSealedByManifest(String className, Manifest manifest) {
if (manifest == null) {
return false;
}
int pos = className.lastIndexOf('.');
if (pos < 0) {
return false;
}
String packageEntry = className.substring(0, pos + 1).replace('.', '/');
Attributes packageAttributes = manifest.getAttributes(packageEntry);
String sealed = null;
if (packageAttributes != null) {
// 包条目属性优先级高于主属性。
sealed = packageAttributes.getValue(Attributes.Name.SEALED);
}
if (sealed == null) {
sealed = manifest.getMainAttributes().getValue(Attributes.Name.SEALED);
}
return "true".equalsIgnoreCase(sealed);
}
}
EOF03.9|运行入口:对照加载路径
文件:src-runner/Main.java
cat > src-runner/Main.java <<'EOF'
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.Path;
import java.nio.file.Paths;
public final class Main {
public static void main(String[] args) throws Exception {
Path appJar = Paths.get("build/app-sealed.jar").toAbsolutePath();
Path injectedJar = Paths.get("build/injected.jar").toAbsolutePath();
Path mergedJar = Paths.get("build/merged-sealed.jar").toAbsolutePath();
// 不同 JAR:观察标准加载器、缺陷加载器、修复加载器的差异。
runUrlClassLoaderDifferentJar(appJar, injectedJar);
runLooseLoaderDifferentJar(appJar, injectedJar);
runFixedLoaderDifferentJar(appJar, injectedJar);
// 同一 JAR:证明 sealed package 允许同一来源内的同包类型。
runUrlClassLoaderSameJar(mergedJar);
runFixedLoaderSameJar(mergedJar);
}
private static void runUrlClassLoaderDifferentJar(Path appJar, Path injectedJar) throws Exception {
System.out.println("=== URLClassLoader / different JAR ===");
URL[] urls = new URL[] {
appJar.toUri().toURL(),
injectedJar.toUri().toURL()
};
try (URLClassLoader loader = new URLClassLoader(urls, null)) {
// 先加载 Gate,使 com.acme.sealed 包完成定义。
Class<?> gate = Class.forName("com.acme.sealed.Gate", true, loader);
System.out.println(call(gate, "publicCall"));
System.out.println("package sealed = " + sealedState(gate));
try {
Class<?> injected = Class.forName("com.acme.sealed.Injected", true, loader);
System.out.println(call(injected, "steal"));
} catch (Throwable t) {
printFailure("URLClassLoader rejected", t);
}
}
System.out.println();
}
private static void runLooseLoaderDifferentJar(Path appJar, Path injectedJar) throws Exception {
System.out.println("=== LooseJarLoader / different JAR ===");
ClassLoader loader = new LooseJarLoader(appJar, injectedJar);
// 先加载 Gate,使 com.acme.sealed 包完成定义。
Class<?> gate = Class.forName("com.acme.sealed.Gate", true, loader);
System.out.println(call(gate, "publicCall"));
System.out.println("package sealed = " + sealedState(gate));
try {
Class<?> injected = Class.forName("com.acme.sealed.Injected", true, loader);
System.out.println(call(injected, "steal"));
} catch (Throwable t) {
printFailure("LooseJarLoader failed", t);
}
System.out.println();
}
private static void runFixedLoaderDifferentJar(Path appJar, Path injectedJar) throws Exception {
System.out.println("=== FixedJarLoader / different JAR ===");
ClassLoader loader = new FixedJarLoader(appJar, injectedJar);
// 先加载 Gate,使 com.acme.sealed 包完成定义。
Class<?> gate = Class.forName("com.acme.sealed.Gate", true, loader);
System.out.println(call(gate, "publicCall"));
System.out.println("package sealed = " + sealedState(gate));
try {
Class<?> injected = Class.forName("com.acme.sealed.Injected", true, loader);
System.out.println(call(injected, "steal"));
} catch (Throwable t) {
printFailure("FixedJarLoader rejected", t);
}
System.out.println();
}
private static void runUrlClassLoaderSameJar(Path mergedJar) throws Exception {
System.out.println("=== URLClassLoader / same JAR ===");
URL[] urls = new URL[] { mergedJar.toUri().toURL() };
try (URLClassLoader loader = new URLClassLoader(urls, null)) {
Class<?> gate = Class.forName("com.acme.sealed.Gate", true, loader);
Class<?> injected = Class.forName("com.acme.sealed.Injected", true, loader);
System.out.println(call(gate, "publicCall"));
System.out.println("package sealed = " + sealedState(gate));
System.out.println(call(injected, "steal"));
}
System.out.println();
}
private static void runFixedLoaderSameJar(Path mergedJar) throws Exception {
System.out.println("=== FixedJarLoader / same JAR ===");
ClassLoader loader = new FixedJarLoader(mergedJar);
Class<?> gate = Class.forName("com.acme.sealed.Gate", true, loader);
Class<?> injected = Class.forName("com.acme.sealed.Injected", true, loader);
System.out.println(call(gate, "publicCall"));
System.out.println("package sealed = " + sealedState(gate));
System.out.println(call(injected, "steal"));
System.out.println();
}
private static Object call(Class<?> type, String methodName) throws Exception {
// 实验方法均为 public static,无需构造实例。
return type.getMethod(methodName).invoke(null);
}
private static String sealedState(Class<?> type) {
Package pkg = type.getPackage();
return pkg == null ? "no Package object" : String.valueOf(pkg.isSealed());
}
private static void printFailure(String label, Throwable t) {
// 反射调用失败时展开 InvocationTargetException,输出异常类型。
Throwable x = t;
while (x instanceof InvocationTargetException
&& ((InvocationTargetException) x).getTargetException() != null) {
x = ((InvocationTargetException) x).getTargetException();
}
System.out.println(label + ": " + x.getClass().getName() + ": " + x.getMessage());
}
}
EOF03.10|核心包编译
mkdir -p build/app-classes
javac -d build/app-classes src-app/com/acme/sealed/*.java
find build/app-classes -type f | sort
03.11|封闭核心 JAR 打包
jar cfm build/app-sealed.jar manifest/MANIFEST.MF -C build/app-classes .
jar tf build/app-sealed.jar | sort
03.12|外部同包名类编译
mkdir -p build/inject-classes
javac -cp build/app-sealed.jar -d build/inject-classes src-inject/com/acme/sealed/Injected.java
find build/inject-classes -type f | sort
编译期能够通过,是因为 Injected.java 声明了相同包名,并且 classpath 中存在 PackageSecret。这不代表运行期一定能加载成功;运行期还要受 sealed package 来源校验影响。
03.13|外部注入 JAR 打包
jar cf build/injected.jar -C build/inject-classes .
jar tf build/injected.jar | sort
03.14|同源合并 JAR 打包
先复制到独立路径,再打包,避免重复条目影响 JAR 生成。
mkdir -p build/merged-classes
cp -R build/app-classes/. build/merged-classes/
cp -R build/inject-classes/. build/merged-classes/
jar cfm build/merged-sealed.jar manifest/MANIFEST.MF -C build/merged-classes .
jar tf build/merged-sealed.jar | sort
03.15|加载器编译与运行
mkdir -p build/runner-classes
javac -d build/runner-classes src-runner/*.java
运行
java -cp build/runner-classes Main
04|包内类型注入的必要前提
包内类型注入成立需要同时满足以下条件:
- 受保护类与注入类使用相同包名,如
com.acme.sealed。 - 注入类由同一个自定义
ClassLoader定义。 - 自定义加载器未按 Manifest 调用
definePackage记录封闭来源。 - 目标包中存在包级私有类、方法或字段。
- 注入类存在可执行入口,如插件入口、脚本桥接入口、服务加载入口或反射调用入口。
缺少同一加载器条件时,包名相同也不会形成同一运行时包。缺少可执行入口时,同包类型即使被定义,也不会自然产生调用效果。
sealed package 的触发点不是 Java 源码编译阶段,而是类加载阶段。
Injected.java能成功编译,只说明编译期的包级访问检查通过;真正决定运行期行为的是Package封闭状态与类来源 URL。
05|标准行为、失效行为与修复行为

关键观测点是 LooseJarLoader / different JAR。app-sealed.jar 的 Manifest 已声明 Sealed: true,但运行时输出为 package sealed = false,说明缺陷加载器没有把 sealed package 语义写入 Package 元数据。随后 Injected 被同一个加载器定义到 com.acme.sealed 运行时包中,因此可以直接访问包级私有方法 PackageSecret.read()。

与之对照,URLClassLoader 和 FixedJarLoader 在不同 JAR 来源下都保持 package sealed = true,并拒绝来自 injected.jar 的同包类。same JAR 两组结果则说明 sealed package 限制的是来源一致性,而不是禁止同一来源内存在多个同包类。
06|从 Manifest 到字节码调用
06.1|Manifest 落盘状态
mkdir -p build/manifest-check
cd build/manifest-check
jar xf ../app-sealed.jar META-INF/MANIFEST.MF
cat META-INF/MANIFEST.MF
cd ../..
若 Sealed: true 缺失,app-sealed.jar 不会触发 sealed package 校验。
06.2|包级私有成员状态
javap -classpath build/app-sealed.jar -p com.acme.sealed.PackageSecret
输出中没有 public class,read() 前也没有 public。这证明 Injected 成功调用 read() 时,依赖的是包级访问规则。
06.3|注入调用指令
javap -classpath build/injected.jar:build/app-sealed.jar -c -p com.acme.sealed.Injected
invokestatic 直接指向 PackageSecret.read()。没有反射调用,也没有访问控制绕过 API。
06.4|外部来源依赖
mv build/injected.jar build/injected.jar.bak
java -cp build/runner-classes Main
mv build/injected.jar.bak build/injected.jar
injected.jar 被移走后,different JAR 场景无法找到 Injected。
LooseJarLoader 仍然是
package sealed = false
三个 different JAR 场景都出现 ClassNotFoundException,两个 same JAR 场景仍可执行:

merged-sealed.jar 内部包含 Injected,因此不依赖 injected.jar
这说明 Injected 的可用性与类来源布局直接相关。merged-sealed.jar 场景仍可执行,是因为它不依赖外部 injected.jar。
07|包级访问为何被放行
Injected.steal() 能直接调用 PackageSecret.read(),不是因为使用了 setAccessible(true),也不是因为关闭了访问检查,而是因为 JVM 在解析与校验访问时判定二者处于同一运行时包。
LooseJarLoader 的关键缺陷位于 src-runner/LooseJarLoader.java 的以下逻辑:
if (getDefinedPackage(pkgName) == null) {
definePackage(pkgName, null, null, null, null, null, null, null);
}该调用显式创建了未封闭包。后续 defineClass 将 Gate 与 Injected 都定义到同一个 LooseJarLoader 下的 com.acme.sealed 包中,访问条件随即成立。
形成的状态可表示为:
Manifest 声明:Sealed: true
运行时 Package:isSealed() == false
Gate 定义加载器:LooseJarLoader
Injected 定义加载器:LooseJarLoader
包级访问结果:允许URLClassLoader 与 FixedJarLoader 在不同 JAR 场景中的状态不同:
Manifest 声明:Sealed: true
运行时 Package:isSealed() == true
Gate 来源:app-sealed.jar
Injected 来源:injected.jar
来源一致性:不一致
加载结果:拒绝同一 JAR 场景中的状态如下:
Manifest 声明:Sealed: true
运行时 Package:isSealed() == true
Gate 来源:merged-sealed.jar
Injected 来源:merged-sealed.jar
来源一致性:一致
加载结果:允许sealed package 不是加密机制,也不是权限沙箱。它只阻止不同代码来源继续向同一包追加类型。自定义加载器跳过 Manifest 处理后,JAR 打包方基于包边界建立的封装假设会失效。
08|在 defineClass 前恢复封闭语义
修复位置必须在 defineClass 之前。核心策略如下:
1. 从类来源 JAR 读取 Manifest
2. 解析主属性和包属性中的 Sealed
3. 包尚未定义时,使用 definePackage 记录 sealBase
4. 包已经定义且处于封闭状态时,检查当前来源 URL 是否一致
5. 包已经定义为未封闭状态时,拒绝后续封闭来源混入
6. 校验通过后再调用 defineClass修复分支位于 src-runner/FixedJarLoader.java:
if (existing == null) {
definePackage(pkgName, null, null, null, null, null, null,
sealedByManifest ? sealBase : null);
return;
}
if (existing.isSealed() && !existing.isSealed(sealBase)) {
throw new SecurityException("sealing violation: package " + pkgName + " is sealed");
}
if (!existing.isSealed() && sealedByManifest) {
throw new SecurityException("sealing violation: package " + pkgName + " was already loaded as unsealed");
}sealBase 必须与类来源一致。sealBase 的取值位于 src-runner/FixedJarLoader.java,实验中使用 JAR 文件 URL:
URL sealBase = jar.toUri().toURL();当 Gate 来自 app-sealed.jar 时,包被绑定到 app-sealed.jar。当 Injected 来自 injected.jar 时,existing.isSealed(sealBase) 返回 false,加载器抛出 SecurityException。
若加载器不准备支持 sealed package,也不应静默忽略 Manifest。更安全的选择是:发现 JAR Manifest 包含 Sealed: true 时拒绝加载,或禁止多个 JAR 定义同一包名。
包级私有适合表达模块内部协作,不适合作为不可信代码隔离边界。只要不可信字节码能由同一个加载器定义到同名包下,包级私有成员就可能被直接调用。
09|sealed package 依赖加载器执行
JAR sealed package 的实际效果依赖类加载器实现。URLClassLoader 会根据 Manifest 维护封闭包约束,自定义 ClassLoader 若只读取字节并调用 defineClass,封闭语义会丢失。
实验中,LooseJarLoader 将 app-sealed.jar 中声明为封闭的包定义成未封闭包,随后成功加载 injected.jar 中的同包类 Injected,并直接访问 PackageSecret.read()。该现象证明 sealed package 校验缺失会导致包内类型注入。
修复路径明确:在 defineClass 前读取 Manifest,按包定义或校验 Package,对封闭包执行来源一致性检查。若业务加载器允许外部字节码进入同一个定义加载器,还需要将包名占用、JAR 来源和 Manifest 语义纳入加载前检查。