-
-
[原创]Java-SQL注入
-
发表于: 2022-10-18 23:31
-
最近比较忙，发点存货。。。
创建连接对象使用CreateStatement()
JDBC使用Statement是不安全的，需要程序员做好过滤，所以一般使用JDBC的程序员会更喜欢使用PrepareStatement做预编译，预编译不仅提高了程序执行的效率，还提高了安全性。
使用Statement来操作数据库比较常见的场景是直接使用+拼接SQL语句，如下图
例如String id获取的参数为1，那么此时的SQL语句为
因为这里并未对String id参数进行过滤，所以传入'and updatexml(1,concat(0x7e,(SELECT user()),0x7e),1)--%20+就会造成SQL注入，那么此时的语句变成下面这样
可以看到传入的单引号闭合了前面的单引号，并且最后使用--+注释原来的单引号，这样就导致了SQL注入。
Tips: 不过这里做一个思考，Java是一个强类型的语言，那么在使用id来代表参数，那么大概率接收的是一个int类型的值，我认为如果站在java开发的角度上想，这里如果定义为int id是不是就不会造成注入了呢？
手动修改一下这里的代码，然后启动
很显然，这里报错了，因为是类型转换的问题，我们传入的Str没办法转成int，所以这里及时存在SQL注入，在这种类型的限制下，也没有办法进行SQL语句拼接
PrepareStatement与Statement的区别对SQL语句进行预编译处理，预编译的好处除了在一定程度上防止SQL注入之外，还减少了SQL语句的编译次数，有效的提高了性能，而SQL注入只对编译过程有破坏作用，执行阶段只是把输入串作为数据处理，不需要再对SQL语句进行解析，因此解决了注入问题。
因为SQL语句编译阶段是进行词法分析、语法分析、语义分析等过程的，也就是说编译过程识别了关键字、执行逻辑之类的东西，编译结束了这条SQL语句能干什么就定了。而在编译之后加入注入的部分，就已经没办法改变执行逻辑了，这部分就只能是相当于输入字符串被处理
1、prepareStatement会先初始化SQL，先把这个SQL提交到数据库中进行预处理，多次使用可提高效率，而Statement不会初始化，没有预处理，每次都是从0开始执行SQL。
2、prepareStatement可以在SQL中用?替换变量，而createStatement不支持 ? 替换变量，只能在sql中拼接参数
3、在使用功能上的区别
如果想要删除三条数据
对于createStatement，需要写三条语句
而prepareStatement，通过set不同数据只需要生成一次执行计划，可以重用
总结
Statement每次执行sql语句，数据库都要执行sql语句的编译，最好用于仅执行一次查询并返回结果的情形，效率高于PreparedStatement.但存在sql注入风险。PreparedStatement是预编译执行的。在执行可变参数的一条SQL时，PreparedStatement要比Statement的效率高，因为DBMS预编译一条SQL当然会比多次编译一条SQL的效率高。安全性更好，有效防止SQL注入的问题。对于多次重复执行的语句，使用prepareStatement，因为数据库会对sql语句进行预编译，下次执行相同的sql语句时，数据库端不会再进行预编译了，而直接用数据库的缓冲区，提高数据访问的效率（但尽量采用使用？号的方式传递参数），如果sql语句只执行一次，以后不再复用。
原理是采用了预编译的方法，先将SQL语句中可被客户端控制的参数集进行编译，生成对应的临时变量集，再使用对应的设置方法，为临时变量集里面的元素进行赋值，赋值函数setString()，会对传入的参数进行强制类型检查和安全检查，所以就避免了SQL注入的产生。下面具体分析。
Statement之所以会被sql注入是因为SQL语句结构发生了变化。比如：
Sql
而Preparement样式为
Sql
该SQL语句会在得到用户的输入之前先用数据库进行预编译，这样的话不管用户输入什么用户名和密码的判断始终都是并的逻辑关系，防止了SQL注入。
简单总结，参数化能防注入的原因在于，语句是语句，参数是参数，参数的值并不是语句的一部分，数据库只按语句的语义跑。
在代码中可以看到，这里使用了prepareStatement对SQL语句进行预编译处理，但是还是使用+号拼接的方式拼接了前端传入的参数，没有使用?号做占位符，这样就导致了prepareStatement预编译处理防止SQL注入失效了。
在控制台中可以看到打印的SQL语句
Tips: 来看看使用?号占位符的时候SQL语句的样子
不难发现使用?号占位符之后，传入的参数还是会在''中间，因为传入的只会当做字符串作为解析
新增一个方法，改一下代码
然后构造参数请求接口
在in当中使用拼接而不使用占位符做预编译的原因是因为很多时候无法确定Ids里含有多少个对象
例如下面的语句
稍微改一下代码
首先为什么预编译无法防止order by注入，因为order by的子域后面需要加上字段名或者字段位置，但是字段名是不能带引号的，否则会被认为是一个字符串，但是使用PreapareStatement会强制给参数加上单引号
但是如果给order by加上单引号，可以发现order by的排序功能失效了
这里有三个对照组可以参考，所以在使用order by语句的时候必须拼接Statement，所以如果使用order by的话，需要对传入的参数进行过滤。
Mybatis下有两种传参方式，分别是\${}以及#{}，
其区别是
1、传入的参数在SQL中显示为字符串（当成一个字符串），会对自动传入的数据加一个双引号。
例：使用以下SQL
当我们传递的参数id为 "1" 时，上述 sql 的解析为：
$传入的参数在SqL中直接显示为传入的值
例：使用以下SQL
当我们传递的参数id为 "1" 时，上述 sql 的解析为：
1、$号作用相当于是字符串拼接
相当于使用StringBuffer的append方法将${username}$追加在
select username,pass from t_login where username=后面，拼接在一起。
2、#号作用相当于变量值替换
相当于使用PreparedStement接口来对#{username}#来进行赋值操作。
1、在sql语句中，如果要接收传递过来的变量的值的话，必须使用#。因为使用#是通过PreparedStement接口来操作，可以防止sql注入，并且在多次执行sql语句时可以提高效率。
2、只是简单的字符串拼接而已，所以要特别小心sql注入问题。对于sql语句中非变量部分，那就可以使用$，比如$方式一般用于传入数据库对象(如传入表名)。
例如：
对于不同的表执行统一的查询操作时，就可以使用$来完成。
例：MyBatis排序时使用order by 动态参数时需要注意，用$而不是#。
最直观的两条SQL语句就可以证明为什么不能使用#号
这里很明显能够发现，当加上单引号之后，排序就失效了，这是为什么呢？
1、在Mysql中，如果order by后面是一个字符串，那么mysql根据一个常量列进行排序，但是所有常量的值都相等，所以就不会进行排序
2、Mybatis在使用#号引用参数的时候，会自动给参数两端加上引号，导致排序失效，因此MyBatis中使用Order by推荐使用$号
因为表名不允许使用引号，直接引用就报错，但是使用#号又会给表名加上单引号，导致报错，所以推荐使用$号
【底层实现原理】在框架底层，是JDBC中的PreparedStatement类在起作用，PreparedStatement是我们很熟悉的Statement的子类，它的对象包含了编译好的SQL语句。这种“准备好”的方式不仅能提高安全性，而且在多次执行同一个SQL时，能够提高效率。原因是SQL已编译好，再次执行时无需再编译。
随后访问接口构造报错函数
try catch堆栈信息
由于使用 #{} 会将对象转成字符串，形成 order by "user" desc 造成错误，因此很多研发会采用${}来解决，从而造成SQL注入
orderby在Mybatis如下
请求接口查看SQL执行的语句
然后手动执行一下SQL语句就知道差异是什么了
可以看到，在使用单引号加上order by排序的字段之后，orderby的排序功能直接失效，那么预编译处理的参数传进去之后肯定是有单引号的，故此会造成SQL注入
Hibernate是一个开源的对象关系映射（ORM：Object Relation Mapping）框架，对JDBC进行了非常轻量级的对象封装，采用映射元数据（配置文件）来描述对象-关系的映射细节，是一个全自动的orm框架。hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
ORM是一种思想
Hibernate查询方式主要有get/load主键查询，对象导航查询、HQL查询、Criteria查询、SQLQuery本地SQL查询。审计的方法主要是搜索createQuery()、createSQLQuery、criteria、createNativeQuery()，查看与其相关的上下文，检查是否存在拼接sql。
整体目录结构
Hibernate对原生SQL查询的支持和控制是通过SQLQuery接口实现的，这种方式弥补了HQL、Criterion查询的不足，其直接使用sql语句进行查询，在操作和使用上往往更加的自由和灵活，如果使用得当，数据库操作的效率还会得到不同程度的提升。一般复杂的sql都会用到它。
该方法与常规的SQL注入没什么区别，存在注入点直接拼接就可以造成注入，无条件限制。
新版本hibernate已经弃用createSQLQuery()，可使用createNativeQuery()代替。
当查询数据时，人们往往需要设置查询条件。在SQL或HQL语句中，查询条件常常放在where子句中。此外，Hibernate还支持Criteria查询（Criteria Query），这种查询方式把查询条件封装为一个Criteria对象。在实际应用中，使用Session的createCriteria()方法构建一个org.hibernate.Criteria实例，然后把具体的查询条件通过Criteria的add()方法加入到Criteria实例中。这样，程序员可以不使用SQL甚至HQL的情况下进行数据查询。
参数绑定优点：
（1）安全性
在HQL查询语句中用”?”来定义参数位置，形式如下：
同样使用setXXX()方法设定绑定参数，只不过这时setXXX()方法的第一个参数代表绑定参数在HQL语句中出现的位置编号（由0开始编号），第二个参数仍然代表参数实际值。
注：在实际开发中，提倡使用按名称绑定命名参数，因为这不但可以提供非常好的程序可读性，而且也提高了程序的易维护性，因为当查询参数的位置发生改变时，按名称邦定名参 数的方式中是不需要调整程 序代码的。
在Hibernate的HQL查询中可以通过setParameter()方法邦定任意类型的参数，如下代码：
如上面代码所示，setParameter()方法包含三个参数，分别是命名参数名称，命名参数实际值，以及命名参数映射类型。对于某些参数类型setParameter()方法可以根据参数值的Java类型，猜测出对应的映射类型，因此这时不需要显示写出映射类型，像上面的例子，可以直接这样写：
query.setParameter(“customername”,name);但是对于一些类型就必须写明映射类型，比如java.util.Date类型，因为它会对应Hibernate的多种映射类型，比如Hibernate.DATA或者Hibernate.TIMESTAMP。
在Hibernate中可以使用setProperties()方法，将命名参数与一个对象的属性值绑定在一起，如下程序代码：
setProperties()方法会自动将customer对象实例的属性值匹配到命名参数上，但是要求命名参数名称必须要与实体对象相应的属性同名。
它会把命名参数与一个持久化对象相关联，如下面代码所示：
上面的代码会生成类似如下的SQL语句：
1、https://xz.aliyun.com/t/10686#toc-0
2、https://b1ngz.github.io/java-sql-injection-note/
3、https://zhuanlan.zhihu.com/p/134037462
4、https://zhuanlan.zhihu.com/p/42841510
5、https://developer.aliyun.com/article/271035#:~:text=%E5%AE%83%E4%BB%AC%E9%83%BD%E4%B8%93%E7%94%A8%E4%BA%8E%E5%8F%91%E9%80%81,%E5%B7%B2%E5%AD%98%E5%82%A8%E8%BF%87%E7%A8%8B%E7%9A%84%E8%B0%83%E7%94%A8%E3%80%82&text=Statement%E6%95%88%E7%8E%87%E4%BC%9A%E6%9B%B4%E9%AB%98%E4%B8%80%E7%82%B9%E3%80%82
6、https://www.cnblogs.com/zsh-blogs/p/10574381.html
7、https://zhuanlan.zhihu.com/p/42841510
8、https://c0d3p1ut0s.github.io/MyBatis%E6%A1%86%E6%9E%B6%E4%B8%AD%E5%B8%B8%E8%A7%81%E7%9A%84SQL%E6%B3%A8%E5%85%A5/
9、https://c0d3p1ut0s.github.io/%E7%AE%80%E5%8D%95%E8%AF%B4%E8%AF%B4MySQL-Prepared-Statement/
10、https://www.dineshonjava.com/hibernate/understanding-parameter-binding-and-sql/
11、https://www.digitalocean.com/community/tutorials/hibernate-query-language-hql-example-tutorial
12、https://blog.csdn.net/u011721501/article/details/43918203
13、Java代码审计之SQL注入——Hibernate框架-SecIN (sec-in.com)
14、https://blog.csdn.net/qq_36908872/article/details/103523165
Statement stmt = null;
try {
stmt = conn.createStatement( );
. . .
}catch (SQLException e) { . . .
}finally {
stmt.close();
}Statement stmt = null;
try {
stmt = conn.createStatement( );
. . .
}catch (SQLException e) { . . .
}finally {
stmt.close();
}@GetMapping("/vul1")
public String vul1(String id) {
StringBuilder result = new StringBuilder();
try {
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn = DriverManager.getConnection(db_url, db_user, db_pass);
Statement stmt = conn.createStatement();
String sql = "select * from users where id = '" + id + "'";
log.info("[vul] 执行SQL语句： " + sql);
ResultSet rs = stmt.executeQuery(sql);
while (rs.next()) {
String res_name = rs.getString("user");
String res_pass = rs.getString("pass");
String info = String.format("查询结果 %s: %s", res_name, res_pass);
result.append(info);
}
rs.close();
stmt.close();
conn.close();
return result.toString();
} catch (Exception e) {
// 输出错误，用于报错注入
return e.toString();
}
}@GetMapping("/vul1")
public String vul1(String id) {
StringBuilder result = new StringBuilder();
try {
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn = DriverManager.getConnection(db_url, db_user, db_pass);
Statement stmt = conn.createStatement();
String sql = "select * from users where id = '" + id + "'";
log.info("[vul] 执行SQL语句： " + sql);
ResultSet rs = stmt.executeQuery(sql);
while (rs.next()) {
String res_name = rs.getString("user");
String res_pass = rs.getString("pass");
String info = String.format("查询结果 %s: %s", res_name, res_pass);
result.append(info);
}
rs.close();
stmt.close();
conn.close();
return result.toString();
} catch (Exception e) {
// 输出错误，用于报错注入
return e.toString();
}
}select * from users where id = '1'
select * from users where id = '1'
select * from users where id = ''and updatexml(1,concat(0x7e,(SELECT user()),0x7e),1)--%20+'
select * from users where id = ''and updatexml(1,concat(0x7e,(SELECT user()),0x7e),1)--%20+'
String sql = "select * from users where id = ?";
PreparedStatement st = conn.prepareStatement(sql);
st.setString(1, id);
ResultSet rs = st.executeQuery();
String sql = "select * from users where id = ?";
PreparedStatement st = conn.prepareStatement(sql);
st.setString(1, id);
ResultSet rs = st.executeQuery();
String sql = "delete from category where id = 2" ;
String sql = "delete from category where id = 3" ;
String sql = "delete from category where id = 7" ;
String sql = "delete from category where id = 2" ;
String sql = "delete from category where id = 3" ;
String sql = "delete from category where id = 7" ;
String sql = "delete from category where id = ？" ;
String sql = "delete from category where id = ？" ;
SQL = “SELECT * FROM users WHERE (name = ‘” + userName + “’) and (pw = ‘”+ passWord +”’);”
//如果恶意填入
userName = “1’ OR ‘1’=’1”;
passWord = “1’ OR ‘1’=’1”;
//将变成
SQL = SELECT * FROM users WHERE (name = ‘1’ OR ‘1’=’1’) and (pw = ‘1’ OR ‘1’=’1’);
//相当于
SQL = SELECT * FROM users;
SQL = “SELECT * FROM users WHERE (name = ‘” + userName + “’) and (pw = ‘”+ passWord +”’);”
//如果恶意填入
userName = “1’ OR ‘1’=’1”;
passWord = “1’ OR ‘1’=’1”;
//将变成
SQL = SELECT * FROM users WHERE (name = ‘1’ OR ‘1’=’1’) and (pw = ‘1’ OR ‘1’=’1’);
//相当于
SQL = SELECT * FROM users;
SELECT * FROM users WHERE userName=? and passWord=?
SELECT * FROM users WHERE userName=? and passWord=?
public String vul2(String id) {
StringBuilder result = new StringBuilder();
try {
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn = DriverManager.getConnection(db_url, db_user, db_pass);
String sql = "select * from users where id = " + id;
log.info("[vul] 执行SQL语句： " + sql);
PreparedStatement st = conn.prepareStatement(sql);
ResultSet rs = st.executeQuery();
while (rs.next()) {
String res_name = rs.getString("user");
String res_pass = rs.getString("pass");
String info = String.format("查询结果%n %s: %s%n", res_name, res_pass);
result.append(info);
}
rs.close();
st.close();
conn.close();
return result.toString();
} catch (Exception e) {
return e.toString();
}
}public String vul2(String id) {
StringBuilder result = new StringBuilder();
try {
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn = DriverManager.getConnection(db_url, db_user, db_pass);
String sql = "select * from users where id = " + id;
log.info("[vul] 执行SQL语句： " + sql);
PreparedStatement st = conn.prepareStatement(sql);
ResultSet rs = st.executeQuery();
while (rs.next()) {
String res_name = rs.getString("user");
String res_pass = rs.getString("pass");
String info = String.format("查询结果%n %s: %s%n", res_name, res_pass);
result.append(info);
}
rs.close();
st.close();
conn.close();
return result.toString();
} catch (Exception e) {
return e.toString();
}
}public String safe_test(String id) {
StringBuilder result = new StringBuilder();
try {
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn = DriverManager.getConnection(db_url, db_user, db_pass);
String sql_1 = "where user like '%" + id + "%'";
String sql = "select * from users " + sql_1;
System.out.println("拼接后语句为: " + sql);
PreparedStatement st = conn.prepareStatement(sql);
log.info("[safe] 执行SQL语句： " + st);
ResultSet rs = st.executeQuery();
result.append("成功");
rs.close();
st.close();
conn.close();
return result.toString();
} catch (Exception e) {
return e.toString();
}
}public String safe_test(String id) {
StringBuilder result = new StringBuilder();
try {
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn = DriverManager.getConnection(db_url, db_user, db_pass);
String sql_1 = "where user like '%" + id + "%'";
String sql = "select * from users " + sql_1;
System.out.println("拼接后语句为: " + sql);
PreparedStatement st = conn.prepareStatement(sql);
log.info("[safe] 执行SQL语句： " + st);
ResultSet rs = st.executeQuery();
result.append("成功");
rs.close();
st.close();
conn.close();
return result.toString();
} catch (Exception e) {
return e.toString();
}
}GET /SQLI/JDBC/test1?id=1%25'+or+sleep(3)%23 HTTP/1.1
Host: 192.168.0.35:8888
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:103.0) Gecko/20100101 Firefox/103.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: closeCookie: JSESSIONID=F445CA5F0CF6B1BE279BC0FA438873E6
GET /SQLI/JDBC/test1?id=1%25'+or+sleep(3)%23 HTTP/1.1
Host: 192.168.0.35:8888
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:103.0) Gecko/20100101 Firefox/103.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: closeCookie: JSESSIONID=F445CA5F0CF6B1BE279BC0FA438873E6
select * from users where id in (2,3);
# 使用占位符就需要select * from users where id in (?, ?);
# 那么有多个语句呢？如何动态的更新？select * from users where id in (2,3);
# 使用占位符就需要select * from users where id in (?, ?);
# 那么有多个语句呢？如何动态的更新？select id,name,age from student where id =#{id}
select id,name,age from student where id =#{id}
select id,name,age from student where id ="1"
select id,name,age from student where id ="1"
select id,name,age from student where id =${id}
select id,name,age from student where id =${id}
select id,name,age from student where id =1
select id,name,age from student where id =1
select * from `${tableName}$`
select * from `${tableName}$`
select * from users order by id;
select * from users order by 'id';
select * from users order by id;
select * from users order by 'id';
package com.uzju.hsql; import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;
@Entity @Table(name = "ADDRESS")
public class Address {
@Id @Column(name = "emp_id", unique = true, nullable = false)
@GeneratedValue(generator = "gen")
@GenericGenerator(name = "gen", strategy = "foreign",
parameters = { @Parameter(name = "property", value = "employee") })
private long id;
@Column(name = "address_line1")
private String addressLine1;
@Column(name = "zipcode")
private String zipcode;
@Column(name = "city")
private String city;
@OneToOne @PrimaryKeyJoinColumn private Employee employee;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getAddressLine1() {
return addressLine1;
}
public void setAddressLine1(String addressLine1) {
this.addressLine1 = addressLine1;
}
public String getZipcode() {
return zipcode;
}
public void setZipcode(String zipcode) {
this.zipcode = zipcode;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public Employee getEmployee() {
return employee;
}
public void setEmployee(Employee employee) {
this.employee = employee;
}
}package com.uzju.hsql; import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;
@Entity @Table(name = "ADDRESS")
public class Address {
@Id @Column(name = "emp_id", unique = true, nullable = false)
@GeneratedValue(generator = "gen")
@GenericGenerator(name = "gen", strategy = "foreign",
parameters = { @Parameter(name = "property", value = "employee") })
private long id;
@Column(name = "address_line1")
private String addressLine1;
@Column(name = "zipcode")
private String zipcode;
@Column(name = "city")
private String city;
@OneToOne @PrimaryKeyJoinColumn private Employee employee;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getAddressLine1() {
return addressLine1;
}
public void setAddressLine1(String addressLine1) {
this.addressLine1 = addressLine1;
}
public String getZipcode() {
return zipcode;
}
public void setZipcode(String zipcode) {
this.zipcode = zipcode;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public Employee getEmployee() {
return employee;
}
[招生]科锐逆向工程师培训(2024年11月15日实地，远程教学同时开班, 第51期)
总结得太全了！
