sql注入

我们要先明确，java是强类型语言，实战我想我们也遇到不少尝试sql注入但是遇到java强制类型要求，参数只能是integer类型的java报错，这种是不存在sql注入的，所以只有变量是String类型的时候，才会存在sql注入。

现在就来看看常规的可以执行sql语句的程序：

JDBC

1、jdbc的java.sql.Statement

Statement是Java JDBC下执行SQL语句的一种原生方式，执行语句时需要通过拼接来执行。若拼接的语句没有经过过滤，将出现SQL注入漏洞

publicstaticvoidmain(String[] args) {// 数据库连接信息Stringurl="jdbc:mysql://localhost:3306/security";Stringusername="root";Stringpassword="root";Connectionconnection=null;Statementstatement=null;ResultSetresultSet=null;try {// 加载数据库驱动            Class.forName("com.mysql.cj.jdbc.Driver");// 获取数据库连接            connection = DriverManager.getConnection(url, username, password);// 创建 Statement 对象            statement = connection.createStatement();// 执行 SQL 查询Stringsql="select * from users";  //这里是String            resultSet = statement.executeQuery(sql);// 处理查询结果while (resultSet.next()) {// 假设表中有 id 和 name 两列intid= resultSet.getInt("id");Stringname= resultSet.getString("username");Stringpass= resultSet.getString("password");                System.out.println("ID: " + id + ", Name: " + name + ", Password: "+pass);            }        } catch (Exception e) {            e.printStackTrace();        } finally {// 关闭资源try {if (resultSet != null) resultSet.close();if (statement != null) statement.close();if (connection != null) connection.close();            } catch (Exception e) {                e.printStackTrace();            }        }    }

2、jdbc的PreparedStatement

PreparedStatement使用了预编译的方式，是statement的升级版，更加安全、效率也更高。能有效防止sql注入

publicstaticvoidmain(String[] args) {// 数据库连接信息Stringurl="jdbc:mysql://localhost:3306/security";Stringusername="root";Stringpassword="root";Connectionconnection=null;PreparedStatementpreparedStatement=null;ResultSetresultSet=null;try {// 加载数据库驱动            Class.forName("com.mysql.cj.jdbc.Driver");// 获取数据库连接            connection = DriverManager.getConnection(url, username, password);// 创建预编译的 SQL 语句Stringsql="SELECT * FROM users WHERE id = ?";            preparedStatement = connection.prepareStatement(sql);// 设置参数            preparedStatement.setInt(1, 1);//如果是int型则用setInt方法，如果是string型则用setString方法// 执行查询            resultSet = preparedStatement.executeQuery();// 处理查询结果while (resultSet.next()) {// 假设表中有 id 和 name 两列intid= resultSet.getInt("id");Stringname= resultSet.getString("username");Stringpass= resultSet.getString("password");                System.out.println("ID: " + id + ", Name: " + name + ", Password: "+pass);            }            System.out.println(preparedStatement);        } catch (Exception e) {            e.printStackTrace();        } finally {// 关闭资源try {if (resultSet != null) resultSet.close();if (preparedStatement != null) preparedStatement.close();if (connection != null) connection.close();            } catch (Exception e) {                e.printStackTrace();            }        }    }

ORM简介

ORM 是一种编程技术，用于在面向对象的编程语言（如 Java、Python）和关系型数据库（如 MySQL、PostgreSQL）之间进行数据映射。它的主要目的是让开发者使用面向对象的方式操作数据库，而不是直接写 SQL。也就是说它不是直接与数据库尽心交互，而是通过操作对象间接操作数据库。

Mybatis下的sql注入

MyBatis 是对 JDBC 的进一步封装与优化，它属于 半自动化的 ORM 框架，相比 Hibernate 灵活性更强，保留了 SQL 的可控性与性能优势。

工作原理简述：

• • 开发者在 Mapper 文件（XML）中提前定义 SQL 语句。
• • 在 Java 正文中，只需调用 Mapper 接口方法，框架会自动完成 SQL 执行。
• • MyBatis 本质上是对 JDBC 的封装与升级版，简化了数据库操作流程。

直接步入mybtis的sql查询，根据上面的原理简述，我们的sql语句在Mapper的xml文档中，所以下面的代码也是Mapper文件中的。

安全用法（#{}）：

<selectid="getUserById"resultType="User">    SELECT * FROM users WHERE id = #{id}</select>

生成的 SQL：

SELECT*FROM users WHERE id = ?

参数通过 JDBC 绑定，无法注入。

危险用法（${}）

<selectid="getUsersBySort"resultType="User">    SELECT * FROM users ORDER BY ${sortColumn}</select>

如果 sortColumn 是用户输入，传入：

sortColumn=id desc; DROP TABLE users --

最终拼接为：

SELECT*FROM users ORDERBY id desc; DROPTABLE users --

造成严重 SQL 注入漏洞，其利用形同最简单的sql注入

下面我们来看看常见的肯能存在漏洞的几种情况

基础漏洞代码

预编译语法错误导致sql注入，预编译虽然能够防止sql注入，但是如果程序员没有养成良好的习惯，也会存在sql注入的风险

Stringsql="SELECT * FROM users WHERE id = ?";            String username1="null";            sql = sql + " and username like '%" + username1 + "%'";

如果我的username1传参为user%' or '1'='1'# ，此时语句就变成了

SELECT * FROM users WHERE id = 1 and username like '%user%' or '1'='1'#%’

返回结果也会是全部信息

下面就看一看需要用到${}的情况

Order by 注入

还有就是order by注入（order by 字段名）不能使用预编译的写法，因为order by语句后面必须要跟字段名（username、id这种）或者字段列数（1、2这种），字段列数肯定是可以预编译的，因为它是Integer类型，但是如果要采用字段名进行排序，就会出现问题，因为setString(1,username)后会自动给usernname套一个引号，而引号会让数据库认为这是一个字符串，而不是字段名，导致order by语句失效，字段列数就不会导致无法使用预编译，如下就是使用预编译的情况下的order by情况：

可以看到并没有使用username进行排序

我换为username所在的字段列数2试试，

这就成功了。所以要么是字段列数+预编译进行排序，要么就是字段名+不使用预编译的方式，

这里就也看看存在order by注入的漏洞代码

Stringsort="username";Stringsql="select * from users order by " + sort;        System.out.println(sql);try (Connectionconnection= DriverManager.getConnection(url, username, password);Statementstatement= connection.createStatement();ResultSetresultSet= statement.executeQuery(sql)) {while (resultSet.next()) {// 处理结果集Stringname= resultSet.getString("username");                System.out.println(name);            }        } catch (SQLException e) {            e.printStackTrace();        }

sort就是注入点：sort=”EXTRACTVALUE(1, CONCAT(0x7e, (SELECT DATABASE()), 0x7e))”

简单利用

Like模糊查询

select * from Book where name LIKE '%${id}%'，语法不会报错，但是会存在sql注入

select * from Book where name LIKE '%#{id}%' ，语法会报错

为什么？

因为#{}相当于jdbc中的预编译，相当于语句为select * from Book where name LIKE '%?%'

%?%，mysql是无法识别语句的，无法识别语法，所以会报错

模糊查询变式

对于模糊查询不代表就不能使用#{}了，下面就是可以使用几种变式来实现预编译

1、concat函数拼接： SELECT * FROM student WHERE name LIKE CONCAT('%', #{stuName}, '%')

2、mysql语法糖：SELECT * FROM student WHERE name LIKE "%"#{stuName}"%"

这就很好的规避了之前无法预编译的问题

in查询

我们现在先明确in查询有何妙用，它主要实现的功能是把原本只查询的id这个字段替换为了一个数组，来实现多次查询，从而避免查询语句的冗余，达到多次查询的结果。

2. 多值查询in之后的参数

Select * from news where id in(#{id})

这样的SQL语句虽然能执行但得不到预期结果，于是研发人员将SQL查询语句修改如下：

Select * from news where id in(${id})

修改后如下

所以就无法被预编译保护，存在sql注入

in查询变式

采用list数组传入，而不是通过字符串，这个方式就成功避免了无法预编译的问题

publicstaticvoidmain(String[] args) {BookDaoinbookDao=newBookDaoin();        List<Integer> ids = Arrays.asList(1, 2);        List<Book> books = bookDao.getBooksByIds(ids);        books.forEach(System.out::println);    }    xml文件        <select id="selectBookByIds" parameterType="list" resultType="com.mybatis.dao.Book">        SELECT * FROM Book WHERE id IN        <foreach collection="list" item="id" open="(" separator="," close=")">            #{id}        </foreach>    </select>

实战正则

${

实战一下

这是xx医院管理系统，其中用了Spring boot、mybatis框架

我们通过检索mapper文件的${ ，来找sql注入，找到如下结果

因为用了Spring boot，我们就顺从其框架逻辑，主要一般会分成三层：Controller、Server、Dao

Controller → Service → DAO → Database

• • Controller：处理 HTTP 请求（如接收前端参数）。
• • Service：处理业务逻辑（如校验参数、事务管理）。
• • DAO：直接操作数据库（如执行 SQL）。

所以我们就是使用从下往上去追踪getOption

Dao层

Server层

Controller层

看重要部分

mapper文档中，${}包裹的column是用columnName以路由的形式传入

此处也没什么别的过滤，简单构造一下payload:

http://10.19.241.45:8081/yiyaoguanlixitong/option/users/(select%20database())最终的sql语句为：SELECT distinct(select database()) FROM users WHERE(select database()) IS NOT NULL AND(select database()) != ''

我们直接去web端是验证一下

JPA & Hibernate下的sql注入

JPA & Hibernate简介

Hibernate 是一个功能强大的 ORM 框架，可以把 Java 对象和数据库表自动进行映射。JPA（Java Persistence API） 是 Java 官方定义的 ORM 标准接口，它不是真正的 ORM 实现，而是一组 规范（接口）。JPA 就像 JDBC 的接口，而 Hibernate 是 JPA 的实现类。

HQL注入

因为其高度封装性，我们看不到语句，更看到参数值。难道他就不存在sql注入了吗，那是不可能的。其实他存在HQL注入，HQL(Hibernate Query Language) 是面向对象的查询语言, 它和 SQL 查询语言有些相似。HQL查询并不直接发送给数据库，而是由hibernate引擎对查询进行解析并解释，然后将其转换为SQL。因为不是直接与数据库进行交互，所以此处使用单引号是无法判断是否存在sql语句的。那我们如何判断呢？

最基础的漏洞代码：

publicstaticvoidmain(String[] args) {Configurationconfiguration=newConfiguration();Configurationconfigure= configuration.configure("hibernate.cfg.xml");SessionFactorysessionFactory= configure.buildSessionFactory();Sessionsession= sessionFactory.openSession();try {// 模拟用户输入（可能来自控制台、网页等）StringuserInput="2 or 1=1";  // ⚠️ 注入点// 不安全：字符串拼接构造 HQLStringhql="from Book where id = " + userInput;        Query<Book> query = session.createQuery(hql, Book.class);Bookbook= query.uniqueResult();if (book != null) {            System.out.println(book.toString());        } else {            System.out.println("未找到对应的书籍记录");        }    } catch (Exception e) {        e.printStackTrace();    } finally {if (session != null) {            session.close();        }if (sessionFactory != null) {            sessionFactory.close();        }    }

这里通过 2 or 1=1 来判断是否存在注入，同时还要确保2是已存在的字段，那我们不知道存在字段呢，那只能使用枚举爆破了。

看起来报错了，但是是存在sql注入的，只是说查询函数返回的数据限制为1。这里返回三条所以报错了。

我们还可以使用更高级的模糊查询，String userInput = "0 or name like 'A%'"，这个name是怎么来的，也是通过枚举、爆破、猜解的。依次遍历字符表 A-Z, a-z, 0-9，可以逐步枚举出字段值。

HQL 限制说明

• • 不支持 UNION SELECT；
• • 不能像原生 SQL 那样使用注入查看系统表（如 information_schema）；
• • 你只能基于对象模型注入，所以字段名要提前知道；
• • 不支持 - 注释（但某些实现允许 /* comment */）；

防注入写法

publicstaticvoidmain(String[] args) {Configurationconfiguration=newConfiguration();Configurationconfigure= configuration.configure("hibernate.cfg.xml");SessionFactorysessionFactory= configure.buildSessionFactory();Sessionsession= sessionFactory.openSession();try {// 模拟用户输入（可能来自控制台、网页等）StringuserInput="1";  // 示例输入LongbookId= Long.parseLong(userInput);// ----------------------------// ✅ 方式一：HQL + 参数绑定（推荐）// ----------------------------Stringhql="from Book where id = :id";  //绑定参数，book不是表是实体类名，:id 是占位符            Query<Book> query = session.createQuery(hql, Book.class);  //创建一个 HQL 查询            query.setParameter("id", bookId);  // 设置参数值Bookbook1= query.uniqueResult(); // 执行查询并获取结果            printResult("HQL + 参数绑定", book1); // 打印结果// ----------------------------// ✅ 方式二：Criteria API 查询// ----------------------------CriteriaBuildercb= session.getCriteriaBuilder(); // 创建 CriteriaBuilder            CriteriaQuery<Book> cq = cb.createQuery(Book.class); // 创建 CriteriaQuery            Root<Book> root = cq.from(Book.class); // 创建 Root            cq.select(root).where(cb.equal(root.get("id"), bookId)); // 添加查询条件Bookbook2= session.createQuery(cq).uniqueResult(); // 执行查询并获取结果            printResult("Criteria API", book2); // 打印结果// ----------------------------// ✅ 方式三：session.get() 主键查// ----------------------------Bookbook3= session.get(Book.class, bookId); // 使用 session.get() 主键查询            printResult("session.get()", book3); // 打印结果        } catch (Exception e) {            e.printStackTrace();        } finally {if (session != null) session.close();if (sessionFactory != null) sessionFactory.close();        }    }privatestaticvoidprintResult(String method, Book book) {        System.out.println("n[查询方式: " + method + "]");if (book != null) {            System.out.println(book.toString());        } else {            System.out.println("未找到对应的书籍记录");        }    }

HQL + 参数绑定：

适用于：需要使用 HQL 编写复杂查询语句时优点：语义清晰、灵活度高、支持复杂筛选和排序防注入机制：通过 :参数名 + setParameter() 实现安全绑定

Criteria API 查询：

适用于：构建动态、多条件、复杂查询时，完全对象化操作优点：类型安全、可编程构建、免拼接防注入机制：值通过 API 构造器设置，无字符串拼接风险

session.get() 主键查询：

适用于：只根据主键查数据（id）时优点：语法最简单，效率高防注入机制：get() 方法内部安全绑定主键参数

由于hibernate的sql注入确实及其少见，没有什么比较好的案例，我们了解其原理，以后遇到了翻翻笔记再实战即可

总结

对于java的sql注入，着重体现在框架、模块的注入，我们的代码审计的关注点也要根据对应搭建的框架进行特定化挖掘。