JAR 被放进 classpath,并不代表它已经完成验签。

1. 类路径只决定搜索范围

JAR 放进 classpath 后,JVM 是否会立即验证其中所有签名条目?

答案是否定的。JAR 签名保护的是 ZIP 条目内容与 META-INF 签名文件之间的哈希链路。把 JAR 文件写入 -cp 只代表它成为类搜索路径的一部分;只有当 ClassLoader 真正读取某个 class 条目并准备定义该 class 时,相关条目的哈希错误才会暴露。

1.1 工具

java -version
javac -version
jar --version
jarsigner -help | head -n 1
python3 --version

1.2 题记

本文主要区分两种动作:

  • 只把失效 JAR 放入 classpath,但不加载其中的业务 class。
  • 通过 Class.forName() 主动加载被修改过的已签名 class。

这两个动作的结果不同,正好可以定位 JAR 签名校验发生的边界。

2. 反射入口固定加载时机

入口类 app.Main 通过反射加载指定类,并打印该 class 的来源与证书数量。这样可以把“JAR 被放入类路径”和“class 真正被加载”两个阶段分开观察。

​src/app/Main.java

package app;

import java.security.CodeSource;
import java.security.cert.Certificate;

// 反射入口:把 classpath 挂载与 class 定义两个阶段分开
public class Main {
    public static void main(String[] args) throws Exception {
        // --noop 分支只启动 JVM,不请求任何签名 JAR 中的 class
        if (args.length == 1 && "--noop".equals(args[0])) {
            System.out.println("noop=true");
            System.out.println("signed jar classes are not requested");
            return;
        }

        // 未指定参数时使用默认目标类
        String[] targets = args.length == 0
                ? new String[]{"signedpkg.SignedGreeter"}
                : args;

        for (String target : targets) {
            run(target);
        }
    }

    private static void run(String target) throws Exception {
        System.out.println("target=" + target);

        // Class.forName 会触发 ClassLoader 读取 class 条目
        // 如果该条目属于已签名 JAR,摘要不匹配会在这里暴露
        Class<?> type = Class.forName(target);
        Object instance = type.getDeclaredConstructor().newInstance();
        Object message = type.getMethod("message").invoke(instance);

        // 证书数量用于判断当前 class 是否来自已验证的签名条目
        CodeSource source = type.getProtectionDomain().getCodeSource();
        Certificate[] certificates = source == null ? null : source.getCertificates();

        System.out.println("message=" + message);
        System.out.println("codeSource=" + (source == null ? "null" : source.getLocation()));
        System.out.println("certificates=" + (certificates == null ? 0 : certificates.length));
    }
}

待签名的业务类如下:

​src/signedpkg/SignedGreeter.java

package signedpkg;

// 待签名的业务类:类名、方法签名固定,只用返回字符串区分版本
public class SignedGreeter {
    public String message() {
        // 字符串常量会进入 class 常量池,后续便于确认字节码变化
        return "signed-v1";
    }
}

2.1 目录结构

2.2 写入反射入口类

app.Main 是实验入口。它有两个作用:一是在 --noop 模式下只启动程序、不加载签名 JAR 中的业务类;二是在普通模式下通过 Class.forName() 精确触发目标 class 的加载。

​src/app/Main.java

package app;

import java.security.CodeSource;
import java.security.cert.Certificate;

// 反射入口类,分离“挂载 classpath”与“定义 class”两个阶段
public class Main {
    public static void main(String[] args) throws Exception {
        // 只运行 JVM 但不加载业务类,用来观察挂载阶段是否触发校验
        if (args.length == 1 && "--noop".equals(args[0])) {
            System.out.println("noop=true");
            System.out.println("signed jar classes are not requested");
            return;
        }

        String[] targets = args.length == 0
                ? new String[]{"signedpkg.SignedGreeter"}
                : args;

        for (String target : targets) {
            run(target);
        }
    }

    private static void run(String target) throws Exception {
        System.out.println("target=" + target);

        // 反射触发目标 class 的读取与定义
        Class<?> type = Class.forName(target);
        Object instance = type.getDeclaredConstructor().newInstance();
        Object message = type.getMethod("message").invoke(instance);

        // 通过 CodeSource 拿到 class 的实际来源及签名证书
        CodeSource source = type.getProtectionDomain().getCodeSource();
        Certificate[] certificates = source == null ? null : source.getCertificates();

        System.out.println("message=" + message);
        System.out.println("codeSource=" + (source == null ? "null" : source.getLocation()));
        System.out.println("certificates=" + (certificates == null ? 0 : certificates.length));
    }
}

2.3 写入待签名业务类

signedpkg.SignedGreeter 会被单独打进库 JAR,并作为后续签名、篡改、追加条目的实验对象。

​src/signedpkg/SignedGreeter.java

package signedpkg;

// 后续所有签名、篡改、追加实验都围绕这个类展开
public class SignedGreeter {
    public String message() {
        return "signed-v1";
    }
}

2.4 编译源码

两个类先统一编译到 build/classes。后面打包时再按包路径拆分,分别生成入口 JAR 和待签名库 JAR:

javac -d build/classes src/app/Main.java src/signedpkg/SignedGreeter.java

2.5 打包入口 JAR

入口 JAR 只包含 app.Main。它本身不参与签名,作用是稳定地触发或跳过业务类加载:

# 只把 app 包打进入口 JAR,与待签名库 JAR 保持分离
jar --create --file build/app.jar \
  -C build/classes app

2.6 打包待签名库 JAR

库 JAR 只包含 signedpkg.SignedGreeter.class。后续所有 JAR 签名与重打包现象都围绕这个制品展开:

# 库 JAR 只放待签名的业务 class,方便对比签名前后的差异
jar --create --file build/signed-lib-unsigned.jar \
  -C build/classes signedpkg/SignedGreeter.class

2.7 生成本地证书并签名库 JAR

库 JAR 生成后,使用本地 PKCS12 证书进行签名。

# 生成本地 PKCS12 密钥库
keytool -genkeypair \
  -alias demo \
  -keyalg RSA \
  -keysize 2048 \
  -validity 3650 \
  -keystore build/demo.p12 \
  -storetype PKCS12 \
  -storepass changeit \
  -keypass changeit \
  -dname "CN=Jar Signing Demo, OU=Lab, O=Local, L=Local, ST=Local, C=CN"

对未签名的库 JAR 进行签名,输出到 signed-lib.jar

jarsigner \
  -keystore build/demo.p12 \
  -storetype PKCS12 \
  -storepass changeit \
  -keypass changeit \
  -signedjar build/signed-lib.jar \
  build/signed-lib-unsigned.jar \
  demo

2.8 检查签名条目与运行期证书

签名完成后,JAR 中会多出 Manifest、.SF 和 .RSA 条目:

jar --list --file build/signed-lib.jar

再加载已签名 class,观察返回值和证书数量:

java -cp build/app.jar:build/signed-lib.jar app.Main signedpkg.SignedGreeter

certificates=1 来自 signedpkg.SignedGreeter 的 ProtectionDomain。这说明证书绑定在已经通过验证的 class 来源上,而不是绑定在 classpath 参数本身。

3. Manifest 摘要链路如何建立

JAR 签名并不是简单地在文件中放入一个证书文件。它的核心是条目摘要链路:

  1. META-INF/MANIFEST.MF 记录 JAR 条目的摘要。
  2. .SF 文件记录 Manifest 或 Manifest 中条目的摘要。
  3. .RSA、.DSA 或 .EC 文件对 .SF 内容进行签名。

先查看 Manifest 中的摘要字段:

python3 - <<'PY'
from zipfile import ZipFile

with ZipFile("build/signed-lib.jar") as jar:
    data = jar.read("META-INF/MANIFEST.MF").decode("utf-8")

for line in data.splitlines():
    if line.startswith("SHA-256-Digest:"):
        print("SHA-256-Digest: <base64 digest>")
    else:
        print(line)
PY

再查看 .SF 文件。它继续记录 Manifest 级摘要,形成从条目内容到签名块的校验链路:

python3 - <<'PY'
from zipfile import ZipFile

with ZipFile("build/signed-lib.jar") as jar:
    data = jar.read("META-INF/DEMO.SF").decode("utf-8")

for line in data.splitlines():
    if "SHA-256-Digest" in line:
        print(line.split(":", 1)[0] + ": <base64 digest>")
    else:
        print(line)
PY

用 jarsigner 验证当前 JAR,只截取业务 class、验证结果和证书警告:

LC_ALL=C jarsigner -verify -verbose -certs build/signed-lib.jar 2>&1 \
  | sed -n '/signedpkg\/SignedGreeter.class/p;/jar verified/p;/self-signed/p;/timestamp/p'

sm 中的 s 表示签名已验证,m 表示条目存在于 Manifest。自签名证书和缺少时间戳会影响证书信任策略与长期校验,但不改变当前条目摘要已经匹配这一事实。

4. 覆盖 class 后旧签名立即失效

常见的重打包失败路径:class 内容变了,但 META-INF 下的旧签名文件仍被保留。

篡改版本保持类名、方法名和方法描述符不变,只修改返回字符串。

​src-tamper/signedpkg/SignedGreeter.java

package signedpkg;

// 只改常量池中的字符串
public class SignedGreeter {
    public String message() {
        // 不改变 API,只改变常量池中的字符串
        return "tampered-v2";
    }
}

准备篡改源码目录、编译并覆盖到已签名 JAR,同时保留旧签名文件:

mkdir -p src-tamper/signedpkg build/tamper-classes

编译篡改版本

javac -d build/tamper-classes src-tamper/signedpkg/SignedGreeter.java

复制原始签名 JAR,然后用篡改后的 class 覆盖,但保留旧签名条目

cp build/signed-lib.jar build/signed-lib-tampered.jar

jar --update --file build/signed-lib-tampered.jar \
  -C build/tamper-classes signedpkg/SignedGreeter.class

原始 JAR 中,message() 返回 signed-v1:

javap -classpath build/signed-lib.jar -c signedpkg.SignedGreeter \
  | sed -n '/message()/,/}/p'

覆盖后的 JAR 中,同一方法已经返回 tampered-v2:

javap -classpath build/signed-lib-tampered.jar -c signedpkg.SignedGreeter \
  | sed -n '/message()/,/}/p'

进一步读取两个 JAR 内的 class 条目

python3 - <<'PY'
from zipfile import ZipFile
from hashlib import sha256

origin = ZipFile("build/signed-lib.jar").read("signedpkg/SignedGreeter.class")
tampered = ZipFile("build/signed-lib-tampered.jar").read("signedpkg/SignedGreeter.class")

def find_utf8(data, marker):
    offset = data.find(marker)
    return "not-found" if offset < 0 else hex(offset)

print("same_bytes=" + str(origin == tampered))
print("origin_magic=" + origin[:4].hex())
print("tampered_magic=" + tampered[:4].hex())
print("origin_major_version=" + str(int.from_bytes(origin[6:8], "big")))
print("tampered_major_version=" + str(int.from_bytes(tampered[6:8], "big")))
print("origin_len=" + str(len(origin)))
print("tampered_len=" + str(len(tampered)))
print("origin_utf8_signed_v1_offset=" + find_utf8(origin, b"signed-v1"))
print("tampered_utf8_tampered_v2_offset=" + find_utf8(tampered, b"tampered-v2"))
print("sha256_equal=" + str(sha256(origin).digest() == sha256(tampered).digest()))
PY

两个 class 都是合法 JVM class 文件,魔数均为 CAFEBABE,主版本也一致;问题在于旧 Manifest 中记录的 SHA-256-Digest 仍对应原始 class。覆盖后的条目内容已经改变,因此旧签名链路无法再成立。

直接验证被覆盖后的 JAR,哈希错误会立即暴露:

  jarsigner -verify -verbose build/signed-lib-tampered.jar

但如果只是把这个失效 JAR 放入 classpath,并不加载其中的业务 class,程序仍然可以运行:

java -cp build/app.jar:build/signed-lib-tampered.jar app.Main --noop

一旦请求加载被覆盖的已签名 class,异常栈会进入 JarVerifier 与 ManifestEntryVerifier:

java -cp build/app.jar:build/signed-lib-tampered.jar app.Main signedpkg.SignedGreeter 2>&1 \
  | sed -E 's/:[0-9]+\)/:LINE)/' \
  | sed -n '1,10p'

​classpath 接收一个 JAR 文件名,并不意味着 JVM 会立即验证其中所有条目;签名校验发生在 JAR 条目读取和 class 定义路径上。

5. 混入未签名条目的运行差异

一个 JAR 文件里可以同时存在已签名条目和未签名条目。新增条目如果不在 Manifest 摘要范围内,就不会自动继承已有签名证书。

回到工作目录,为两个未签名 class 准备源码与编译目录

cd /jar-sign-boundary
mkdir -p src-inject/injected src-inject/signedpkg build/inject-classes

先准备一个新增到全新包中的未签名 class。

​src-inject/injected/UnsignedAddon.java

package injected;

// 新增到全新包中的未签名 class
public class UnsignedAddon {
    public String message() {
        // 新包条目没有 Manifest 摘要,也不会携带签名证书
        return "unsigned-added";
    }
}

再准备一个新增到已签名包中的未签名 class。

​src-inject/signedpkg/UnsignedSibling.java

package signedpkg;

// 新增到已签名包中的未签名 class
public class UnsignedSibling {
    public String message() {
        // 与已签名 class 位于同一包,用于触发包内 signer 一致性检查
        return "unsigned-sibling";
    }
}

编译两个新增 class,并追加到原始签名 JAR:

javac -d build/inject-classes \
  src-inject/injected/UnsignedAddon.java \
  src-inject/signedpkg/UnsignedSibling.java

复制原始签名 JAR,把两个未签名 class 追加进去

cp build/signed-lib.jar build/signed-lib-with-unsigned.jar

jar --update --file build/signed-lib-with-unsigned.jar \
  -C build/inject-classes injected/UnsignedAddon.class \
  -C build/inject-classes signedpkg/UnsignedSibling.class

验证追加后的 JAR。原有签名条目仍能通过校验,新增条目会被标记为未签名:

LC_ALL=C jarsigner -verify -verbose build/signed-lib-with-unsigned.jar 2>&1 \
  | sed -n '/signedpkg\/SignedGreeter.class/p;/injected\/UnsignedAddon.class/p;/signedpkg\/UnsignedSibling.class/p;/jar verified/p;/unsigned entries/p'

这里的 jar verified 只表示已有签名条目的摘要和签名链路有效;? 与 unsigned entries 警告说明新增条目没有被完整性保护。仅凭 jar verified 判断制品安全是不够的。

加载新包中的未签名 class,观察证书数量:

java -cp build/app.jar:build/signed-lib-with-unsigned.jar app.Main injected.UnsignedAddon

injected.UnsignedAddon 可以正常加载,但 certificates=0。JAR 中存在 META-INF/DEMO.RSA,并不代表新增条目会自动携带签名证书。

再看同包场景。先加载已签名 class,再加载同包未签名 class:

java -cp build/app.jar:build/signed-lib-with-unsigned.jar app.Main \
  signedpkg.SignedGreeter \
  signedpkg.UnsignedSibling 2>&1 \
  | sed -E 's/:[0-9]+\)/:LINE)/' \
  | sed -n '1,12p'

这个异常不是摘要错误,而是 ClassLoader.checkCerts 的包内 signer 一致性检查。signedpkg.SignedGreeter 定义后,signedpkg 包已经关联了签名者信息;同包未签名 class 再定义时会被拒绝。新包 injected.UnsignedAddon 没有既有 signer 约束,因此能够加载。

6. 删除旧签名与重新签名的差异

重打包、字节码增强、shade、压缩重建等操作都可能改变 JAR 条目内容或元数据。处理旧签名时,常见结果有三种:保留旧签名、删除旧签名、重新签名。

前文已经证明保留旧签名会导致摘要错误;下面继续观察删除与重新签名的差异。

从被覆盖后的 JAR 中删除旧签名块,保留当前 class 内容:

python3 - <<'PY'
from zipfile import ZipFile, ZIP_DEFLATED

source = "build/signed-lib-tampered.jar"
target = "build/signed-lib-stripped.jar"
signature_suffixes = (".SF", ".RSA", ".DSA", ".EC")

with ZipFile(source) as zin, ZipFile(target, "w", ZIP_DEFLATED) as zout:
    for item in zin.infolist():
        name = item.filename
        upper = name.upper()

        if upper.startswith("META-INF/") and upper.endswith(signature_suffixes):
            print("drop " + name)
            continue

        zout.writestr(item, zin.read(name))
PY

删除签名块后,JAR 中只剩 Manifest 和业务 class:

jar --list --file build/signed-lib-stripped.jar

(META-INF 空目录不算)

运行删除签名块后的 JAR:

java -cp build/app.jar:build/signed-lib-stripped.jar app.Main signedpkg.SignedGreeter

哈希错误消失,并不是因为旧签名被修复,而是因为签名块被移除后,JVM 不再把该 class 当成已签名条目处理。certificates=0 是直接证据。

对删除旧签名块后的 JAR 重新签名:

LC_ALL=C jarsigner \
  -keystore build/demo.p12 \
  -storetype PKCS12 \
  -storepass changeit \
  -keypass changeit \
  -signedjar build/signed-lib-resigned.jar \
  build/signed-lib-stripped.jar \
  demo

重新签名后的 JAR 能通过 jarsigner 验证:

jarsigner -verify -verbose -certs build/signed-lib-resigned.jar 2>&1 \
  | sed -n '/signedpkg\/SignedGreeter.class/p;/jar verified/p;/self-signed/p;/timestamp/p'

运行重新签名后的 class:

java -cp build/app.jar:build/signed-lib-resigned.jar app.Main signedpkg.SignedGreeter

message=tampered-v2 与 certificates=1 同时出现,说明当前内容已经被新的签名文件覆盖。这个结果只证明当前 JAR 内容与当前签名匹配,并不表示原始签名方仍然为 signed-v1 版本背书。

7. 构建阶段拦截异常 JAR

运行期才发现签名错误,通常已经太晚。更稳妥的做法是在构建或发布阶段验证最终制品,拒绝以下情况:

  • 条目摘要错误或签名块损坏。
  • JAR 完全未签名。
  • JAR 中混入未签名条目。

下面的脚本适合作为发布前检查的基础版本。

​verify-release-jar.sh

#!/usr/bin/env bash
set -euo pipefail

jar_file="${1:?usage: ./verify-release-jar.sh <jar>}"
out="$(mktemp)"
trap 'rm -f "$out"' EXIT

if ! LC_ALL=C jarsigner -verify -verbose -certs "$jar_file" >"$out" 2>&1; then
  cat "$out"
  exit 1
fi

if ! grep -q "jar verified" "$out"; then
  cat "$out"
  echo "reject: jar is not verified"
  exit 1
fi

if grep -q "unsigned entries" "$out"; then
  cat "$out"
  echo "reject: jar contains unsigned entries"
  exit 1
fi

echo "accept: $jar_file"

写入检查脚本并赋予执行权限:

chmod +x verify-release-jar.sh

原始签名 JAR被接受:

./verify-release-jar.sh build/signed-lib.jar

覆盖 class 后仍保留旧签名的 JAR 应被拒绝:

./verify-release-jar.sh build/signed-lib-tampered.jar

混入未签名条目的 JAR 也被拒绝:

./verify-release-jar.sh build/signed-lib-with-unsigned.jar

删除签名块后的 JAR 不能被当作已验证制品:

./verify-release-jar.sh build/signed-lib-stripped.jar

重新签名后的 JAR 重新进入可接受状态:

./verify-release-jar.sh build/signed-lib-resigned.jar

这个脚本不把“存在 META-INF/*.RSA”当作准入条件,而是以 jarsigner 的验证结果和未签名条目警告作为判断依据。本文使用自签名证书是为了本地复现;如果进入受控发布链路,还应额外校验证书链、签名时间戳和允许的签名者证书指纹。

8. 运行期按实际加载的 class 校验证书

构建阶段验证 JAR 只能保证制品文件符合策略。对于插件式加载、用户指定 classpath、路径覆盖、运行时拼接依赖等场景,还需要对实际加载的 class 做运行期检查。

下面的 app.RequireSigned 会加载指定 class,并拒绝未携带签名证书的 class。

​src/app/RequireSigned.java

package app;

import java.security.CodeSource;
import java.security.cert.Certificate;

// 只接受带有签名证书的 class
public class RequireSigned {
    public static void main(String[] args) throws Exception {
        // 无参数时直接抛出,防止误用
        if (args.length == 0) {
            throw new IllegalArgumentException("usage: app.RequireSigned <class> [class...]");
        }

        for (String name : args) {
            // 主动定义目标 class,触发 JarVerifier 的摘要检查
            Class<?> type = Class.forName(name);
            CodeSource source = type.getProtectionDomain().getCodeSource();
            Certificate[] certificates = source == null ? null : source.getCertificates();
            int count = certificates == null ? 0 : certificates.length;

            // 运行期只接受已经通过 JAR 签名验证并携带证书的 class
            if (count == 0) {
                throw new SecurityException("unsigned class rejected: " + name);
            }

            System.out.println("accepted=" + name);
            System.out.println("codeSource=" + source.getLocation());
            System.out.println("certificates=" + count);
        }
    }
}

编译并单独输出到 build/check-classes

javac -d build/check-classes src/app/RequireSigned.java

打包检查工具,与业务 JAR 保持分离

jar --create --file build/check.jar \
  -C build/check-classes app/RequireSigned.class

已签名 class 会被运行期检查接受:

java -cp build/check.jar:build/signed-lib.jar app.RequireSigned signedpkg.SignedGreeter

新增到新包的未签名 class 会被业务策略拒绝:

java -cp build/check.jar:build/signed-lib-with-unsigned.jar app.RequireSigned injected.UnsignedAddon

覆盖 class 且保留旧签名时,业务检查还未执行,JAR 摘要错误已经先触发:

java -cp build/check.jar:build/signed-lib-tampered.jar app.RequireSigned signedpkg.SignedGreeter

运行期检查可以区分三类问题:

场景

触发位置

关键输出

含义

已签名 class 正常加载

ProtectionDomain 证书读取

certificates=1

class 来自已验证签名条目

新包未签名 class

业务检查逻辑

unsigned class rejected

class 可被 JVM 加载,但不符合签名策略

覆盖已签名 class

JAR 条目读取路径

SHA-256 digest error

class 内容与 Manifest 摘要不匹配

9. 重打包链路的判断原则

JAR 签名问题不能只检查文件里是否存在 META-INF/*.RSA,也不能只看 JAR 是否已经进入 classpath。可靠证据应来自条目摘要、jarsigner 输出、运行期 ProtectionDomain 和异常栈。

制品状态

验证命令

关键输出

安全含义

原始签名 JAR

jarsigner -verify -verbose -certs build/signed-lib.jar

jar verified、sm signedpkg/SignedGreeter.class

已签名条目摘要匹配

覆盖 class 后保留旧签名

jarsigner -verify -verbose build/signed-lib-tampered.jar

SHA-256 digest error

旧签名约束与当前 class 内容冲突

追加未签名条目

jarsigner -verify -verbose build/signed-lib-with-unsigned.jar

jar verified、unsigned entries

已签名条目有效,但新增条目不受完整性保护

删除旧签名块

java -cp build/app.jar:build/signed-lib-stripped.jar app.Main signedpkg.SignedGreeter

certificates=0

可运行,但来源已降级为未签名

删除旧签名后重新签名

jarsigner -verify -verbose build/signed-lib-resigned.jar

jar verified、certificates=1

当前内容与新签名链路匹配

实际处理时可以遵循三条原则:

  1. 修改过 class 或资源后,不能继续保留旧签名。 旧 Manifest 中的摘要仍指向原始条目,目标条目被读取时会触发哈希错误。
  2. 删除签名块只能消除旧摘要冲突,不能保留签名属性。 运行期证据会变成 certificates=0,制品应按未签名处理。
  3. 需要签名保障时,应在最终制品上重新签名。 构建阶段应拒绝摘要错误、未签名制品和 unsigned entries,运行期则按实际加载的 class 检查证书信息。

综上,JAR 签名的校验边界不在 classpath 参数本身,而在具体条目的读取与 class 定义路径上。重打包链路只有在最终产物完成后重新签名,并把构建期验证与运行期证据结合起来,才能避免“看起来已签名、实际未受保护”的风险。