公开文集
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-142-OWASP-Top10-2024 详解
# Day 156: OWASP Top 10 2024 详解 > 漏洞与攻防系列第 1 天 | 预计阅读时间:60 分钟 | 难度:★★★★☆ --- **PUA v3 · Sprint 启动** ``` ┌─────────┬────────────────────────────────────┐ │ 清单 任务 │ OWASP Top 10 2024 详解 - Day 156 │ ├─────────┼────────────────────────────────────┤ │ 味道 │ 阿里味(自动:安全任务) │ ├─────────┼────────────────────────────────────┤ │ 压力 │ L0 · 信任期 │ └─────────┴────────────────────────────────────┘ ``` ▎ OWASP Top 10 不是背下来就完事,是理解透。理解不透彻,防护就是表面的。今天深入详解 OWASP Top 10 2024。 --- ## 清单 目录 1. [OWASP Top 10 概述](#owasp-top-10 概述) 2. [A01 失效的访问控制](#a01 失效的访问控制) 3. [A02 加密机制失效](#a02 加密机制失效) 4. [A03 注入攻击](#a03 注入攻击) 5. [A04 不安全设计](#a04 不安全设计) 6. [A05 安全配置错误](#a05 安全配置错误) 7. [A06 易受攻击和过时的组件](#a06 易受攻击和过时的组件) 8. [A07 认证和会话管理失效](#a07 认证和会话管理失效) 9. [A08 软件和数据完整性失效](#a08 软件和数据完整性失效) 10. [A09 安全日志和监控失效](#a09 安全日志和监控失效) 11. [A10 服务端请求伪造](#a10 服务端请求伪造) 12. [总结与思考](#总结与思考) 13. [参考资料](#参考资料) --- ## OWASP Top 10 概述 ### 什么是 OWASP Top 10 > ▎ OWASP Top 10 不是漏洞列表,是风险指南。指南不理解,防护就是盲目的。 **定义与价值**: ``` OWASP Top 10 是开放 Web 应用安全项目 (OWASP) 发布的 Web 应用安全风险指南,代表了最严重和最普遍的 Web 安全风险。 核心价值: 1. 风险意识 - 提高安全意识 - 识别常见风险 - 优先防护重点 2. 防护指南 - 提供防护建议 - 指导安全开发 - 支持安全测试 3. 行业标准 - 行业广泛认可 - 合规参考标准 - 教育培训基础 ``` **版本演进**: ``` ┌─────────────────────────────────────────────────────────┐ │ OWASP Top 10 版本演进 │ ├─────────────────────────────────────────────────────────┤ │ │ │ 2021 版本 → 2024 版本变化 │ │ │ │ A01 注入 → A01 失效的访问控制 (保持) │ │ A02 失效的认证 → A07 认证和会话管理失效 (降级) │ │ A03 敏感数据泄露 → A02 加密机制失效 (升级) │ │ A04 XML 外部实体 → 移除 (合并到注入) │ │ A05 失效的访问控制 → A01 失效的访问控制 (升级) │ │ A06 安全配置错误 → A05 安全配置错误 (保持) │ │ A07 跨站脚本 → 移除 (合并到注入) │ │ A08 反序列化 → A08 软件和数据完整性失效 (扩展) │ │ A09 使用含有已知漏洞的组件 → A06 易受攻击和过时的组件 │ │ A10 不足的日志记录和监控 → A09 安全日志和监控失效 │ │ │ │ 新增风险: │ │ - A04 不安全设计 (新类别) │ │ - A10 服务端请求伪造 SSRF (新类别) │ │ │ └─────────────────────────────────────────────────────────┘ 2024 版本 Top 10: 1. A01:2024 失效的访问控制 2. A02:2024 加密机制失效 3. A03:2024 注入攻击 4. A04:2024 不安全设计 5. A05:2024 安全配置错误 6. A06:2024 易受攻击和过时的组件 7. A07:2024 认证和会话管理失效 8. A08:2024 软件和数据完整性失效 9. A09:2024 安全日志和监控失效 10. A10:2024 服务端请求伪造 ``` ### 风险排名依据 **排名方法**: ```python # OWASP Top 10 排名依据 class OWASPRankingMethodology: """OWASP Top 10 排名方法""" # 评估因素 factors = { 'prevalence': { 'name': '普遍性', 'weight': 0.30, 'description': '漏洞在应用中的普遍程度' }, 'detectability': { 'name': '可检测性', 'weight': 0.15, 'description': '漏洞被发现的难易程度' }, 'technical_impact': { 'name': '技术影响', 'weight': 0.25, 'description': '漏洞造成的技术影响程度' }, 'business_impact': { 'name': '业务影响', 'weight': 0.30, 'description': '漏洞造成的业务影响程度' } } # 2024 年数据来源 data_sources = [ 'SAP 安全研究', 'Reckon 安全数据', 'Acunetix 扫描数据', 'Contrast 实验室数据', 'Mend 组件数据', 'OWASP 社区贡献' ] # 覆盖范围 coverage = { 'applications': 500000, # 50 万 + 应用 'vulnerabilities': 5000000, # 500 万 + 漏洞 'organizations': 10000, # 1 万 + 组织 'countries': 100 # 100+ 国家 } def calculate_risk_score(self, vulnerability_data): """计算风险分数""" score = 0 for factor, info in self.factors.items(): factor_value = vulnerability_data.get(factor, 0) weight = info['weight'] score += factor_value * weight return score def rank_vulnerabilities(self, vulnerabilities): """对漏洞进行排名""" scored_vulns = [] for vuln in vulnerabilities: score = self.calculate_risk_score(vuln) scored_vulns.append({ 'name': vuln['name'], 'score': score, 'data': vuln }) # 按分数排序 scored_vulns.sort(key=lambda x: x['score'], reverse=True) return scored_vulns[:10] # 返回 Top 10 ``` --- ## A01 失效的访问控制 ### 漏洞详解 > ▎ 访问控制不是可有可无,是安全基石。基石不牢固,安全就是危楼。 **漏洞定义**: ``` A01:2024 失效的访问控制 (Broken Access Control) 定义: 攻击者能够绕过授权检查,访问未授权的功能或数据。 常见表现: 1. 越权访问 - 水平越权:访问其他用户的数据 - 垂直越权:访问管理员功能 2. 元数据操作 - 修改 JWT 令牌 - 提升权限级别 3. CORS 配置错误 - 允许未授权域访问 - 暴露敏感 API 4. 强制浏览 - 访问未授权 URL - 绕过访问控制 ``` **漏洞案例**: ```python # 案例 1: 水平越权 # 问题代码 def get_user_profile(user_id): # 错误:没有验证当前用户是否有权访问该用户 ID profile = db.query("SELECT * FROM users WHERE id = ?", user_id) return profile # 攻击方式 # 用户 A 修改请求中的 user_id 参数,访问用户 B 的资料 # GET /api/profile?user_id=123 → GET /api/profile?user_id=456 # 修复代码 def get_user_profile(current_user, requested_user_id): # 正确:验证当前用户是否有权访问 if current_user.id != requested_user_id and not current_user.is_admin: raise ForbiddenError("无权访问该用户资料") profile = db.query("SELECT * FROM users WHERE id = ?", requested_user_id) return profile # 案例 2: 垂直越权 # 问题代码 @app.route('/admin/delete_user') def delete_user(): # 错误:没有权限检查 user_id = request.args.get('user_id') db.delete_user(user_id) return "用户已删除" # 攻击方式 # 普通用户直接访问/admin/delete_user?user_id=123 # 修复代码 @app.route('/admin/delete_user') @require_role('admin') # 需要管理员角色 def delete_user(): user_id = request.args.get('user_id') db.delete_user(user_id) return "用户已删除" # 案例 3: JWT 权限提升 # 问题代码 # 攻击者修改 JWT 中的 role 字段 # {"user_id": 123, "role": "user"} → {"user_id": 123, "role": "admin"} # 修复方案 # 1. JWT 签名验证 # 2. 服务端存储权限信息 # 3. 不信任客户端传来的权限信息 ``` **防护措施**: ```python # 访问控制最佳实践 class AccessControlBestPractices: """访问控制最佳实践""" # 1. 实施最小权限原则 def enforce_least_privilege(self): """ 原则: - 默认拒绝所有访问 - 只授予必要的最小权限 - 定期审查权限 """ pass # 2. 服务端实施访问控制 def server_side_access_control(self): """ 原则: - 不在客户端存储权限信息 - 所有访问在服务端验证 - 不信任客户端传来的权限 """ pass # 3. 实施统一的访问控制机制 def unified_access_control(self): """ 原则: - 使用统一的授权框架 - 避免重复实现 - 集中管理权限 """ pass # 4. 记录访问控制失败 def log_access_failures(self): """ 原则: - 记录所有访问失败 - 告警异常访问模式 - 便于事后调查 """ pass # 5. 限制 CORS def restrict_cors(self): """ 原则: - 限制允许的源 - 不使用通配符 * - 实施适当的 CORS 策略 """ pass # 访问控制检查装饰器 from functools import wraps def require_permission(permission): """权限检查装饰器""" def decorator(func): @wraps(func) def wrapper(*args, **kwargs): current_user = get_current_user() if not current_user.has_permission(permission): log_access_failure(current_user, permission) raise ForbiddenError(f"缺少权限:{permission}") return func(*args, **kwargs) return wrapper return decorator def require_role(role): """角色检查装饰器""" def decorator(func): @wraps(func) def wrapper(*args, **kwargs): current_user = get_current_user() if role not in current_user.roles: log_access_failure(current_user, f"role:{role}") raise ForbiddenError(f"缺少角色:{role}") return func(*args, **kwargs) return wrapper return decorator def check_object_access(obj, user): """对象级访问控制检查""" # 检查用户是否有权访问该对象 if obj.owner_id != user.id and not user.is_admin: return False # 检查共享权限 if obj.shared_with and user.id in obj.shared_with: return True return user.is_admin ``` **测试方法**: ``` 测试检查清单: □ 尝试访问其他用户的数据 □ 尝试访问管理员功能 □ 修改 URL 参数测试越权 □ 修改 JWT 令牌测试权限提升 □ 测试 API 直接访问 □ 测试 CORS 配置 □ 测试强制浏览 □ 测试未授权 HTTP 方法 (PUT, DELETE) ``` --- ## A02 加密机制失效 ### 漏洞详解 > ▎ 加密不是用了就安全,是用对才安全。用不对加密,数据就是裸奔的。 **漏洞定义**: ``` A02:2024 加密机制失效 (Cryptographic Failures) 定义: 未能正确保护敏感数据,导致数据泄露或被篡改。 注意: 2021 版本称为"敏感数据泄露",2024 版本更强调加密机制本身的问题。 常见表现: 1. 明文存储敏感数据 - 密码明文存储 - 个人信息明文存储 - 支付信息明文存储 2. 弱加密算法 - 使用 MD5/SHA1 - 使用 DES/3DES - 使用弱密钥长度 3. 密钥管理不当 - 硬编码密钥 - 密钥泄露 - 密钥不轮换 4. 传输未加密 - HTTP 而非 HTTPS - 内部通信未加密 - 数据库连接未加密 ``` **漏洞案例**: ```python # 案例 1: 密码明文存储 # 问题代码 class User: def __init__(self, username, password): self.username = username self.password = password # 错误:明文存储密码 # 攻击方式 # 数据库泄露后,攻击者直接获取所有用户密码 # 修复代码 import bcrypt class User: def __init__(self, username, password): self.username = username # 正确:使用 bcrypt 哈希密码 self.password_hash = bcrypt.hashpw( password.encode(), bcrypt.gensalt(rounds=12) ).decode() def verify_password(self, password): return bcrypt.checkpw( password.encode(), self.password_hash.encode() ) # 案例 2: 弱加密算法 # 问题代码 import hashlib def hash_password(password): # 错误:使用 MD5,容易被破解 return hashlib.md5(password.encode()).hexdigest() # 攻击方式 # 使用彩虹表或暴力破解快速还原密码 # 修复代码 import argon2 def hash_password(password): # 正确:使用 Argon2 ph = argon2.PasswordHasher() return ph.hash(password) # 案例 3: 硬编码密钥 # 问题代码 from cryptography.fernet import Fernet # 错误:密钥硬编码在代码中 ENCRYPTION_KEY = "hardcoded-secret-key-12345" cipher = Fernet(ENCRYPTION_KEY) # 攻击方式 # 代码泄露后,攻击者可以解密所有数据 # 修复代码 import os # 正确:从环境变量获取密钥 ENCRYPTION_KEY = os.environ.get('ENCRYPTION_KEY') if not ENCRYPTION_KEY: raise ConfigurationError("加密密钥未配置") cipher = Fernet(ENCRYPTION_KEY) # 案例 4: HTTP 传输 # 问题代码 # 网站使用 HTTP 而非 HTTPS # http://example.com/login # 攻击方式 # 中间人攻击,窃取登录凭证 # 修复方案 # 1. 强制使用 HTTPS # 2. 配置 HSTS # 3. 使用 TLS 1.2+ ``` **防护措施**: ```python # 加密最佳实践 class CryptographicBestPractices: """加密最佳实践""" # 1. 使用强加密算法 def use_strong_algorithms(self): """ 推荐算法: - 哈希:Argon2, bcrypt, scrypt, PBKDF2 - 对称加密:AES-256-GCM - 非对称加密:RSA-2048+, ECC - 签名:Ed25519, RSA-PSS 避免算法: - MD5, SHA1 (哈希) - DES, 3DES (对称加密) - RSA-1024 (非对称加密) """ pass # 2. 正确管理密钥 def manage_keys_properly(self): """ 密钥管理原则: - 不硬编码密钥 - 使用密钥管理服务 (KMS) - 定期轮换密钥 - 密钥分级管理 """ pass # 3. 传输加密 def encrypt_in_transit(self): """ 传输加密要求: - 强制使用 HTTPS - 使用 TLS 1.2 或更高 - 配置 HSTS - 使用强密码套件 """ pass # 4. 存储加密 def encrypt_at_rest(self): """ 存储加密要求: - 敏感数据加密存储 - 使用字段级加密 - 数据库透明加密 - 备份数据加密 """ pass # 5. 随机数生成 def use_secure_random(self): """ 随机数要求: - 使用加密安全随机数 - 不使用 random 模块 - 使用 secrets 模块 """ import secrets return secrets.token_hex(32) # 密码存储实现 import argon2 from argon2 import PasswordHasher from argon2.exceptions import VerifyMismatchError class SecurePasswordStorage: """安全密码存储""" def __init__(self): # Argon2 配置 self.ph = PasswordHasher( time_cost=3, # 迭代次数 memory_cost=65536, # 内存使用 (KB) parallelism=4, # 并行度 hash_len=32, # 哈希长度 salt_len=16 # 盐长度 ) def hash_password(self, password): """哈希密码""" return self.ph.hash(password) def verify_password(self, password_hash, password): """验证密码""" try: self.ph.verify(password_hash, password) return True except VerifyMismatchError: return False def needs_rehash(self, password_hash): """检查是否需要重新哈希""" return self.ph.check_needs_rehash(password_hash) # 数据加密实现 from cryptography.fernet import Fernet from cryptography.hazmat.primitives import hashes from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC import base64 import os class SecureDataEncryption: """安全数据加密""" def __init__(self, key=None): if key is None: # 从环境变量获取密钥 key = os.environ.get('ENCRYPTION_KEY') if not key: raise ConfigurationError("加密密钥未配置") self.cipher = Fernet(key) def encrypt(self, plaintext): """加密数据""" return self.cipher.encrypt(plaintext.encode()).decode() def decrypt(self, ciphertext): """解密数据""" return self.cipher.decrypt(ciphertext.encode()).decode() @staticmethod def generate_key(): """生成加密密钥""" return Fernet.generate_key().decode() ``` **测试方法**: ``` 测试检查清单: □ 检查密码是否哈希存储 □ 检查哈希算法强度 □ 检查密钥是否硬编码 □ 检查是否使用 HTTPS □ 检查 TLS 版本和配置 □ 检查敏感数据是否加密 □ 检查随机数生成是否安全 □ 检查证书是否有效 ``` --- ## A03 注入攻击 ### 漏洞详解 > ▎ 注入不是老漏洞,是常青树。防护不到位,注入就是必然的。 **漏洞定义**: ``` A03:2024 注入攻击 (Injection) 定义: 攻击者通过构造恶意输入,欺骗解释器执行非预期命令或访问未授权数据。 2024 版本变化: - 合并了 SQL 注入、XSS、XXE 等注入类漏洞 - 强调所有类型的注入风险 常见类型: 1. SQL 注入 - 数据库查询注入 - 存储过程注入 2. 命令注入 - OS 命令注入 - 代码注入 3. XSS (跨站脚本) - 反射型 XSS - 存储型 XSS - DOM 型 XSS 4. 其他注入 - LDAP 注入 - XML 注入 (XXE) - 模板注入 ``` **漏洞案例**: ```python # 案例 1: SQL 注入 # 问题代码 def login(username, password): # 错误:字符串拼接 SQL query = f"SELECT * FROM users WHERE username='{username}' AND password='{password}'" result = db.execute(query) return result # 攻击方式 # 用户名:admin' -- # 密码:任意 # 最终 SQL: SELECT * FROM users WHERE username='admin' --' AND password='' # 修复代码 def login(username, password): # 正确:参数化查询 query = "SELECT * FROM users WHERE username=? AND password=?" result = db.execute(query, (username, password)) return result # 案例 2: 命令注入 # 问题代码 import os def ping_host(hostname): # 错误:直接拼接命令 os.system(f"ping -c 4 {hostname}") # 攻击方式 # hostname: 127.0.0.1; cat /etc/passwd # 执行:ping -c 4 127.0.0.1; cat /etc/passwd # 修复代码 import subprocess def ping_host(hostname): # 正确:使用列表,不使用 shell subprocess.run(['ping', '-c', '4', hostname], check=True) # 案例 3: XSS (跨站脚本) # 问题代码 @app.route('/search') def search(): query = request.args.get('q', '') # 错误:直接返回用户输入 return f"<h1>搜索结果:{query}</h1>" # 攻击方式 # q=<script>alert(document.cookie)</script> # 修复代码 from markupsafe import escape @app.route('/search') def search(): query = request.args.get('q', '') # 正确:转义输出 return f"<h1>搜索结果:{escape(query)}</h1>" # 案例 4: 模板注入 # 问题代码 from jinja2 import Template def render_template(user_input): # 错误:直接渲染用户输入 template = Template(user_input) return template.render() # 攻击方式 # user_input: {{ config }} # 或:{{ ''.__class__.__mro__[2].__subclasses__() }} # 修复代码 def render_template(template_string, context): # 正确:使用沙箱环境 from jinja2.sandbox import SandboxedEnvironment env = SandboxedEnvironment() template = env.from_string(template_string) return template.render(**context) ``` **防护措施**: ```python # 注入防护最佳实践 class InjectionPrevention: """注入防护最佳实践""" # 1. 使用参数化查询 def use_parameterized_queries(self): """ SQL 注入防护: - 使用预编译语句 - 使用 ORM 框架 - 不拼接 SQL 字符串 """ pass # 2. 输入验证 def validate_input(self): """ 输入验证原则: - 白名单验证 - 类型检查 - 长度限制 - 格式验证 """ pass # 3. 输出编码 def encode_output(self): """ 输出编码原则: - HTML 上下文 HTML 编码 - JS 上下文 JS 编码 - URL 上下文 URL 编码 - 使用安全库 """ pass # 4. 避免危险函数 def avoid_dangerous_functions(self): """ 避免使用的函数: - eval(), exec() - os.system() - subprocess with shell=True - 不安全的反序列化 """ pass # 5. 使用安全 API def use_safe_apis(self): """ 使用安全 API: - 参数化查询 API - 安全模板引擎 - 安全文件操作 API """ pass # 安全查询封装 class SecureDatabase: """安全数据库操作""" def __init__(self, connection): self.conn = connection def query(self, sql, params=None): """安全查询""" cursor = self.conn.cursor() # 参数化查询 if params: cursor.execute(sql, params) else: cursor.execute(sql) return cursor.fetchall() def query_by_id(self, table, id): """按 ID 查询""" # 白名单验证表名 allowed_tables = ['users', 'products', 'orders'] if table not in allowed_tables: raise ValueError("无效的表名") sql = f"SELECT * FROM {table} WHERE id = ?" return self.query(sql, (id,)) # 安全命令执行 class SecureCommandExecutor: """安全命令执行""" # 允许的命令白名单 ALLOWED_COMMANDS = { 'ping': '/bin/ping', 'traceroute': '/usr/bin/traceroute', 'dig': '/usr/bin/dig' } def execute(self, command, args): """安全执行命令""" # 验证命令 if command not in self.ALLOWED_COMMANDS: raise SecurityError("不允许的命令") cmd_path = self.ALLOWED_COMMANDS[command] # 验证参数 safe_args = self.sanitize_args(args) # 执行命令 (不使用 shell) import subprocess result = subprocess.run( [cmd_path] + safe_args, capture_output=True, text=True, timeout=30 ) return result.stdout def sanitize_args(self, args): """清理命令参数""" dangerous_chars = [';', '|', '&', '$', '`', '(', ')', '<', '>'] safe_args = [] for arg in args: for char in dangerous_chars: if char in arg: raise SecurityError("参数包含危险字符") safe_args.append(arg) return safe_args ``` **测试方法**: ``` 测试检查清单: □ SQL 注入测试 □ 命令注入测试 □ XSS 测试 (反射型/存储型/DOM 型) □ LDAP 注入测试 □ XML 注入测试 □ 模板注入测试 □ 文件路径遍历测试 □ 反序列化测试 ``` --- ## A04 不安全设计 ### 漏洞详解 > ▎ 设计不是事后补救,是事前预防。预防不到位,修复就是返工的。 **漏洞定义**: ``` A04:2024 不安全设计 (Insecure Design) 定义: 由于设计阶段缺乏安全考虑,导致系统存在架构层面的安全缺陷。 2024 版本新增: - 这是 2021 版本新增的类别 - 强调安全设计的重要性 - 需要威胁建模和安全设计模式 常见表现: 1. 缺乏威胁建模 - 未识别关键资产 - 未分析威胁场景 - 未设计防护措施 2. 架构缺陷 - 缺乏分层防御 - 信任边界不清 - 单点故障 3. 业务逻辑缺陷 - 流程可绕过 - 状态可篡改 - 竞争条件 4. 缺乏安全控制 - 无速率限制 - 无限重试 - 无限资源 ``` **漏洞案例**: ```python # 案例 1: 缺乏业务逻辑验证 # 问题代码 def process_payment(user, amount): # 错误:没有验证用户余额 # 错误:没有验证交易限额 # 错误:没有防重放机制 user.balance -= amount db.save(user) return "支付成功" # 攻击方式 # 1. 负数支付:amount = -100 # 2. 超额支付:amount = 999999999 # 3. 重放攻击:重复提交同一请求 # 修复代码 def process_payment(user, amount): # 正确:验证金额 if amount <= 0: raise ValueError("金额必须大于 0") # 正确:验证余额 if user.balance < amount: raise InsufficientFundsError("余额不足") # 正确:验证限额 if amount > user.daily_limit: raise LimitExceededError("超过日限额") # 正确:防重放 if request.id in processed_requests: raise ReplayAttackError("重复请求") # 正确:事务处理 with db.transaction(): user.balance -= amount user.daily_spent += amount db.save(user) processed_requests.add(request.id) return "支付成功" # 案例 2: 缺乏速率限制 # 问题代码 @app.route('/login', methods=['POST']) def login(): username = request.form['username'] password = request.form['password'] user = db.get_user(username) if user and verify_password(password, user.password_hash): return create_session(user) return "登录失败" # 攻击方式 # 暴力破解:每秒尝试 100 次密码 # 修复代码 from flask_limiter import Limiter from flask_limiter.util import get_remote_address limiter = Limiter(key_func=get_remote_address) @app.route('/login', methods=['POST']) @limiter.limit("5 per minute") # 限制每分钟 5 次 def login(): username = request.form['username'] password = request.form['password'] user = db.get_user(username) if user and verify_password(password, user.password_hash): return create_session(user) # 记录失败尝试 log_failed_attempt(username) # 账户锁定 if get_failed_attempts(username) >= 5: lock_account(username) return "登录失败" # 案例 3: 竞争条件 # 问题代码 def withdraw(user, amount): # 错误:检查和使用之间存在时间窗口 if user.balance >= amount: # 这里可能被并发请求利用 user.balance -= amount db.save(user) return "取款成功" return "余额不足" # 攻击方式 # 并发发送多个取款请求,利用时间窗口超额取款 # 修复代码 def withdraw(user, amount): # 正确:使用数据库锁 with db.transaction(isolation_level='SERIALIZABLE'): # 重新检查余额 (在锁内) user = db.get_user_for_update(user.id) if user.balance >= amount: user.balance -= amount db.save(user) return "取款成功" return "余额不足" ``` **防护措施**: ```python # 安全设计最佳实践 class SecureDesignPrinciples: """安全设计原则""" # 1. 威胁建模 def threat_modeling(self): """ 威胁建模步骤: 1. 识别资产 2. 创建架构图表 3. 识别威胁 (STRIDE) 4. 评估风险 5. 制定对策 """ pass # 2. 安全设计模式 def secure_design_patterns(self): """ 安全设计模式: - 分层防御 - 最小权限 - 默认安全 - 故障安全 - 完全验证 """ pass # 3. 业务逻辑安全 def business_logic_security(self): """ 业务逻辑安全: - 状态验证 - 流程完整 - 防重放 - 防篡改 """ pass # 4. 资源限制 def resource_limits(self): """ 资源限制: - 速率限制 - 配额管理 - 超时设置 - 并发限制 """ pass # 5. 审计和监控 def audit_and_monitoring(self): """ 审计和监控: - 关键操作日志 - 异常行为检测 - 实时告警 - 可追溯性 """ pass # 安全设计检查清单 class SecureDesignChecklist: """安全设计检查清单""" checklist = { 'threat_modeling': [ '是否进行了威胁建模', '是否识别了关键资产', '是否分析了威胁场景', '是否制定了防护措施' ], 'architecture': [ '是否有分层防御', '信任边界是否清晰', '是否有单点故障', '是否有回滚机制' ], 'authentication': [ '是否有强认证机制', '是否有会话管理', '是否有防暴力破解', '是否有 MFA 支持' ], 'authorization': [ '是否有访问控制', '是否实施最小权限', '是否有权限审计', '是否有越权防护' ], 'data_protection': [ '敏感数据是否加密', '传输是否加密', '密钥是否安全管理', '是否有数据备份' ], 'input_validation': [ '所有输入是否验证', '是否使用白名单', '输出是否编码', '是否有注入防护' ], 'error_handling': [ '错误是否不泄露信息', '是否有统一错误处理', '错误是否记录日志', '是否有恢复机制' ], 'logging_monitoring': [ '关键操作是否日志', '是否有异常检测', '是否有实时告警', '日志是否保护' ] } def review_design(self, design_doc): """审查设计文档""" findings = [] for category, checks in self.checklist.items(): for check in checks: if not self.verify_check(design_doc, check): findings.append({ 'category': category, 'check': check, 'severity': 'medium', 'recommendation': f'需要{check}' }) return findings def verify_check(self, design_doc, check): """验证检查项""" # 实际实现需要检查设计文档 return True ``` **测试方法**: ``` 测试检查清单: □ 威胁建模审查 □ 架构安全审查 □ 业务逻辑测试 □ 竞争条件测试 □ 速率限制测试 □ 资源限制测试 □ 流程绕过测试 □ 状态篡改测试 ``` --- ## A05 安全配置错误 ### 漏洞详解 > ▎ 配置不是小事,是大事。配置不正确,系统就是裸奔的。 **漏洞定义**: ``` A05:2024 安全配置错误 (Security Misconfiguration) 定义: 由于安全配置不当或缺失,导致系统暴露在攻击风险下。 常见表现: 1. 默认配置 - 默认密码 - 默认账户 - 默认配置 2. 不必要的功能 - 未使用的服务 - 调试功能开启 - 示例应用 3. 错误配置 - 错误处理泄露信息 - CORS 配置错误 - 安全头缺失 4. 过时软件 - 未打补丁 - 过时版本 - 不支持的软件 ``` **漏洞案例**: ```python # 案例 1: 调试模式开启 # 问题代码 (Flask) app = Flask(__name__) app.config['DEBUG'] = True # 错误:生产环境开启调试 # 攻击方式 # 访问/error 触发异常,显示堆栈跟踪和源码 # 利用调试控制台执行任意代码 # 修复代码 app = Flask(__name__) app.config['DEBUG'] = False # 正确:生产环境关闭调试 # 使用环境变量 app.config['DEBUG'] = os.environ.get('FLASK_ENV') == 'development' # 案例 2: 默认密码 # 问题代码 # 数据库使用默认密码 DB_PASSWORD = 'admin' # 错误:默认密码 # 攻击方式 # 尝试常见默认密码登录 # 修复方案 # 1. 强制修改默认密码 # 2. 使用强密码策略 # 3. 从安全存储获取密码 DB_PASSWORD = os.environ.get('DB_PASSWORD') # 案例 3: 安全头缺失 # 问题代码 # 响应中没有安全头 @app.route('/api/data') def get_data(): return jsonify({'data': 'value'}) # 攻击方式 # 点击劫持 # XSS 攻击 # MIME 类型混淆 # 修复代码 @app.after_request def add_security_headers(response): response.headers['X-Frame-Options'] = 'DENY' response.headers['X-Content-Type-Options'] = 'nosniff' response.headers['X-XSS-Protection'] = '1; mode=block' response.headers['Content-Security-Policy'] = "default-src 'self'" response.headers['Strict-Transport-Security'] = 'max-age=31536000; includeSubDomains' return response # 案例 4: 详细错误信息 # 问题代码 try: result = db.query(user_input) except Exception as e: return f"错误:{str(e)}" # 错误:泄露详细信息 # 攻击方式 # 获取 SQL 语句结构 # 获取系统路径信息 # 获取内部实现细节 # 修复代码 import logging logger = logging.getLogger(__name__) try: result = db.query(user_input) except Exception as e: logger.error(f"Database error: {e}", exc_info=True) return "发生错误,请稍后重试" # 正确:通用错误信息 ``` **防护措施**: ```python # 安全配置最佳实践 class SecureConfiguration: """安全配置最佳实践""" # 1. 安全基线 def secure_baseline(self): """ 安全基线要求: - 修改默认密码 - 禁用不必要功能 - 移除示例应用 - 更新到最新版本 """ pass # 2. 自动化配置 def automated_configuration(self): """ 自动化配置: - 使用配置管理工具 - 版本控制配置 - 自动化部署 - 配置审计 """ pass # 3. 环境分离 def environment_separation(self): """ 环境分离: - 开发/测试/生产分离 - 不同配置 - 不同凭证 - 不同访问控制 """ pass # 4. 安全头 def security_headers(self): """ 必要安全头: - X-Frame-Options - X-Content-Type-Options - X-XSS-Protection - Content-Security-Policy - Strict-Transport-Security """ pass # 5. 错误处理 def error_handling(self): """ 错误处理要求: - 不泄露敏感信息 - 统一错误格式 - 记录详细日志 - 用户友好提示 """ pass # 配置检查脚本 class ConfigurationChecker: """配置检查器""" checks = { 'debug_mode': { 'description': '检查调试模式是否关闭', 'check': lambda config: not config.get('DEBUG', False), 'severity': 'high' }, 'default_password': { 'description': '检查是否使用默认密码', 'check': lambda config: config.get('password') not in ['admin', 'password', '123456'], 'severity': 'critical' }, 'security_headers': { 'description': '检查安全头是否配置', 'check': lambda headers: all(h in headers for h in [ 'X-Frame-Options', 'X-Content-Type-Options', 'Strict-Transport-Security' ]), 'severity': 'medium' }, 'error_handling': { 'description': '检查错误处理是否安全', 'check': lambda app: not app.config.get('SHOW_ERROR_DETAILS', False), 'severity': 'medium' }, 'unused_features': { 'description': '检查是否禁用不必要功能', 'check': lambda config: not config.get('ENABLE_DEBUG_ENDPOINTS', False), 'severity': 'medium' } } def check_configuration(self, config): """检查配置""" findings = [] for check_name, check_info in self.checks.items(): try: result = check_info['check'](config) if not result: findings.append({ 'check': check_name, 'description': check_info['description'], 'severity': check_info['severity'], 'status': 'failed' }) except Exception as e: findings.append({ 'check': check_name, 'description': check_info['description'], 'severity': 'info', 'status': 'error', 'error': str(e) }) return findings ``` **测试方法**: ``` 测试检查清单: □ 默认配置检查 □ 调试功能检查 □ 安全头检查 □ 错误处理检查 □ 不必要服务检查 □ 软件版本检查 □ 目录列表检查 □ HTTP 方法检查 ``` --- ## A06 易受攻击和过时的组件 ### 漏洞详解 > ▎ 组件不是用了就完事,是持续管理。管理不持续,漏洞就是积累的。 **漏洞定义**: ``` A06:2024 易受攻击和过时的组件 (Vulnerable and Outdated Components) 定义: 使用含有已知漏洞或不再维护的组件,导致系统面临安全风险。 常见表现: 1. 已知漏洞组件 - 未修复 CVE 漏洞 - 未应用安全补丁 - 使用漏洞版本 2. 过时组件 - 不再维护的组件 - 过时的版本 - 废弃的 API 3. 传递依赖 - 间接依赖漏洞 - 依赖树复杂 - 难以追踪 4. 未经验证组件 - 来源不明 - 未验证完整性 - 恶意组件 ``` **漏洞案例**: ```python # 案例 1: Log4j 漏洞 (CVE-2021-44228) # 问题: 使用含漏洞的 Log4j 版本 # 影响: 远程代码执行 # 修复: 升级到 Log4j 2.17.0+ # 案例 2: 过时的 Django 版本 # 问题代码 # requirements.txt Django==2.2.0 # 错误:过时版本,有多个安全漏洞 # 修复代码 # requirements.txt Django==4.2.0 # 正确:使用最新 LTS 版本 # 案例 3: 传递依赖漏洞 # 问题: 直接依赖安全,但传递依赖有漏洞 # 示例: # 项目依赖 A (安全) # A 依赖 B (有漏洞) # B 依赖 C (有漏洞) # 解决: # 1. 使用 SCA 工具扫描 # 2. 强制指定安全版本 # 3. 定期更新依赖 ``` **防护措施**: ```python # 组件管理最佳实践 class ComponentManagement: """组件管理最佳实践""" # 1. 依赖扫描 def dependency_scanning(self): """ 依赖扫描要求: - 使用 SCA 工具 - 定期扫描 - CI/CD 集成 - 阻断高危漏洞 """ pass # 2. 版本管理 def version_management(self): """ 版本管理要求: - 固定版本号 - 使用 Lock 文件 - 避免通配符 - 定期更新 """ pass # 3. 来源验证 def source_verification(self): """ 来源验证要求: - 使用官方源 - 验证签名 - 验证哈希 - 避免不明来源 """ pass # 4. 最小化依赖 def minimize_dependencies(self): """ 最小化原则: - 只使用必要依赖 - 移除未使用依赖 - 评估新依赖 - 减少传递依赖 """ pass # 5. 持续监控 def continuous_monitoring(self): """ 持续监控: - 订阅安全公告 - 监控漏洞数据库 - 自动告警 - 快速响应 """ pass # 依赖检查脚本 #!/usr/bin/env python3 """ 依赖安全检查脚本 """ import subprocess import json def check_python_dependencies(): """检查 Python 依赖""" # 使用 safety 检查 result = subprocess.run( ['safety', 'check', '--json'], capture_output=True, text=True ) vulnerabilities = json.loads(result.stdout) if vulnerabilities: print(f"发现 {len(vulnerabilities)} 个漏洞:") for vuln in vulnerabilities: print(f" - {vuln['package_name']} {vuln['version']}: {vuln['cve_id']}") return False return True def check_npm_dependencies(): """检查 NPM 依赖""" result = subprocess.run( ['npm', 'audit', '--json'], capture_output=True, text=True ) audit = json.loads(result.stdout) if audit['metadata']['vulnerabilities']['total'] > 0: print(f"发现 {audit['metadata']['vulnerabilities']['total']} 个漏洞:") for vuln in audit.get('vulnerabilities', []): print(f" - {vuln['name']}: {vuln['severity']}") return False return True def check_outdated(): """检查过时依赖""" # Python result = subprocess.run( ['pip', 'list', '--outdated'], capture_output=True, text=True ) if result.stdout.strip(): print("有过时的依赖:") print(result.stdout) if __name__ == '__main__': print("=== 依赖安全检查 ===\n") print("检查 Python 依赖...") python_safe = check_python_dependencies() print("\n检查 NPM 依赖...") npm_safe = check_npm_dependencies() print("\n检查过时依赖...") check_outdated() if python_safe and npm_safe: print("\n+ 依赖检查通过") else: print("\n- 发现安全漏洞,请修复") ``` **测试方法**: ``` 测试检查清单: □ 依赖漏洞扫描 □ 组件版本检查 □ 传递依赖分析 □ 来源验证检查 □ 签名验证检查 □ 过时组件检查 □ 未使用依赖检查 □ 安全公告订阅 ``` --- ## A07 认证和会话管理失效 ### 漏洞详解 > ▎ 认证不是有登录就行,是安全登录。登录不安全,门户就是开放的。 **漏洞定义**: ``` A07:2024 认证和会话管理失效 (Identification and Authentication Failures) 定义: 认证和会话管理机制存在缺陷,允许攻击者绕过或破坏认证。 常见表现: 1. 弱密码策略 - 无复杂度要求 - 无长度要求 - 常见密码允许 2. 会话管理缺陷 - 会话固定 - 会话劫持 - 会话超时过长 3. 凭证管理不当 - 明文存储密码 - 硬编码凭证 - 凭证泄露 4. 暴力破解 - 无限重试 - 无账户锁定 - 无验证码 ``` **防护措施**: ```python # 认证和会话管理最佳实践 class AuthenticationBestPractices: """认证最佳实践""" # 1. 强密码策略 def strong_password_policy(self): """ 密码策略要求: - 最小长度 12 位 - 复杂度要求 - 禁止常见密码 - 定期更换 """ pass # 2. 多因素认证 def multi_factor_authentication(self): """ MFA 要求: - 支持 TOTP - 支持短信 - 支持硬件密钥 - 关键操作强制 MFA """ pass # 3. 安全会话管理 def secure_session_management(self): """ 会话管理要求: - 安全随机会话 ID - 会话超时 - 会话轮换 - 登出失效 """ pass # 4. 防暴力破解 def brute_force_protection(self): """ 防护要求: - 登录限流 - 账户锁定 - 验证码 - 延迟响应 """ pass # 5. 安全凭证存储 def secure_credential_storage(self): """ 存储要求: - 密码哈希存储 - 使用强哈希算法 - 加盐哈希 - 不存储明文 """ pass ``` **测试方法**: ``` 测试检查清单: □ 密码策略测试 □ 暴力破解测试 □ 会话固定测试 □ 会话劫持测试 □ 凭证泄露测试 □ MFA 绕过测试 □ 密码重置测试 □ 登出失效测试 ``` --- ## A08 软件和数据完整性失效 ### 漏洞详解 > ▎ 完整性不是小事,是大事。完整性不保,系统就是可信的。 **漏洞定义**: ``` A08:2024 软件和数据完整性失效 (Software and Data Integrity Failures) 定义: 未能验证软件和数据完整性,导致使用被篡改的组件或数据。 常见表现: 1. 不安全的更新 - 未验证更新签名 - 使用 HTTP 更新 - 自动更新无验证 2. 反序列化漏洞 - 不安全的反序列化 - 未验证数据来源 - 反序列化执行代码 3. CI/CD 管道 - 未验证构建完整性 - 未保护 CI/CD 凭证 - 未验证部署包 4. 数据完整性 - 未验证数据完整性 - 未保护数据防篡改 - 未验证数据来源 ``` **防护措施**: ```python # 完整性保护最佳实践 class IntegrityProtection: """完整性保护最佳实践""" # 1. 代码签名 def code_signing(self): """ 签名要求: - 签名所有代码 - 验证签名 - 保护签名密钥 - 使用可信 CA """ pass # 2. 安全更新 def secure_updates(self): """ 更新要求: - HTTPS 传输 - 验证签名 - 验证哈希 - 回滚机制 """ pass # 3. 反序列化安全 def secure_deserialization(self): """ 反序列化要求: - 避免反序列化 - 验证数据来源 - 使用安全格式 - 限制反序列化类 """ pass # 4. CI/CD 安全 def secure_cicd(self): """ CI/CD 要求: - 保护凭证 - 验证构建 - 签名部署包 - 审计变更 """ pass ``` **测试方法**: ``` 测试检查清单: □ 更新签名验证 □ 反序列化测试 □ CI/CD 管道安全 □ 数据完整性验证 □ 来源验证检查 □ 哈希验证检查 □ 回滚机制测试 □ 凭证保护检查 ``` --- ## A09 安全日志和监控失效 ### 漏洞详解 > ▎ 日志不是记了就完事,是有效监控。监控不到位,攻击就是隐形的。 **漏洞定义**: ``` A09:2024 安全日志和监控失效 (Security Logging and Monitoring Failures) 定义: 未能记录关键安全事件或监控不足,导致无法检测和响应安全事件。 常见表现: 1. 日志不足 - 未记录安全事件 - 日志信息不全 - 未记录关键操作 2. 监控不足 - 无实时告警 - 无异常检测 - 无行为分析 3. 日志保护不当 - 日志可篡改 - 日志未加密 - 日志访问无控制 4. 响应不足 - 无应急响应流程 - 无事件响应团队 - 无演练测试 ``` **防护措施**: ```python # 日志和监控最佳实践 class LoggingAndMonitoring: """日志和监控最佳实践""" # 1. 全面日志 def comprehensive_logging(self): """ 日志要求: - 记录所有认证事件 - 记录所有访问控制失败 - 记录所有输入验证失败 - 记录敏感操作 """ pass # 2. 实时监控 def real_time_monitoring(self): """ 监控要求: - 实时告警 - 异常检测 - 行为分析 - 威胁检测 """ pass # 3. 日志保护 def log_protection(self): """ 保护要求: - 日志完整性 - 日志加密 - 访问控制 - 防篡改 """ pass # 4. 应急响应 def incident_response(self): """ 响应要求: - 响应流程 - 响应团队 - 定期演练 - 持续改进 """ pass ``` **测试方法**: ``` 测试检查清单: □ 日志覆盖检查 □ 日志内容检查 □ 告警测试 □ 异常检测测试 □ 日志完整性检查 □ 日志保护检查 □ 响应流程测试 □ 演练测试 ``` --- ## A10 服务端请求伪造 ### 漏洞详解 > ▎ SSRF 不是简单漏洞,是隐蔽杀手。防护不到位,内网就是开放的。 **漏洞定义**: ``` A10:2024 服务端请求伪造 (Server-Side Request Forgery, SSRF) 定义: 攻击者诱导服务器发起非预期的 HTTP 请求,访问内部资源或外部系统。 2024 版本新增: - 从 2021 版本的"其他"类别提升为 Top 10 - 反映 SSRF 威胁的严重性 常见表现: 1. 内部资源访问 - 访问内网服务 - 访问元数据服务 - 访问管理接口 2. 协议滥用 - file:// 协议 - gopher:// 协议 - dict:// 协议 3. 云环境 SSRF - 访问云元数据 - 访问云内部服务 - 凭证窃取 4. 盲 SSRF - 无响应返回 - 基于时间检测 - 基于 DNS 检测 ``` **漏洞案例**: ```python # 案例 1: 基本 SSRF # 问题代码 import requests @app.route('/fetch') def fetch_url(): url = request.args.get('url') # 错误:直接使用用户提供的 URL response = requests.get(url) return response.text # 攻击方式 # 访问内网:?url=http://192.168.1.1/admin # 访问元数据:?url=http://169.254.169.254/latest/meta-data/ # 修复代码 import requests from urllib.parse import urlparse @app.route('/fetch') def fetch_url(): url = request.args.get('url') # 正确:验证 URL parsed = urlparse(url) # 只允许 HTTP/HTTPS if parsed.scheme not in ['http', 'https']: raise ValueError("只允许 HTTP/HTTPS 协议") # 阻止内网地址 import socket import ipaddress hostname = parsed.hostname ip = socket.gethostbyname(hostname) if ipaddress.ip_address(ip).is_private: raise ValueError("不允许访问内网地址") response = requests.get(url) return response.text # 案例 2: 云环境 SSRF # 问题:AWS EC2 元数据服务访问 # 攻击:?url=http://169.254.169.254/latest/meta-data/iam/security-credentials/ # 防护: # 1. 使用 IMDSv2 (需要会话令牌) # 2. 阻止元数据 IP # 3. 网络隔离 ``` **防护措施**: ```python # SSRF 防护最佳实践 class SSRFProtection: """SSRF 防护最佳实践""" # 1. URL 验证 def validate_url(self, url): """ 验证要求: - 白名单协议 - 白名单域名 - 阻止内网 IP - 阻止元数据 IP """ from urllib.parse import urlparse import ipaddress import socket parsed = urlparse(url) # 协议白名单 if parsed.scheme not in ['http', 'https']: return False # 解析 IP try: ip = socket.gethostbyname(parsed.hostname) ip_addr = ipaddress.ip_address(ip) # 阻止私有 IP if ip_addr.is_private: return False # 阻止环回地址 if ip_addr.is_loopback: return False # 阻止链路本地地址 if ip_addr.is_link_local: return False # 阻止云元数据 IP metadata_ips = [ '169.254.169.254', # AWS '100.100.100.200', # Alibaba '168.63.129.16', # Azure ] if str(ip_addr) in metadata_ips: return False except Exception: return False return True # 2. 域名白名单 def domain_whitelist(self): """ 白名单要求: - 只允许信任域名 - 动态配置 - 定期审查 """ pass # 3. 网络隔离 def network_isolation(self): """ 隔离要求: - 出站流量控制 - 元数据服务保护 - 内部服务隔离 """ pass # 4. 使用安全库 def use_safe_libraries(self): """ 安全库: - 使用 SSRF 防护库 - 自动验证 URL - 自动阻止危险请求 """ pass ``` **测试方法**: ``` 测试检查清单: □ 内网地址访问测试 □ 元数据服务访问测试 □ 协议绕过测试 □ DNS 重绑定测试 □ URL 重定向测试 □ IPv6 绕过测试 □ 编码绕过测试 □ 盲 SSRF 测试 ``` --- 统计 **Sprint 交付 · 绩效评估** ``` ┌───────────────┬────────────────┬────────────────┐ │ 主动出击 │ ██████████ 5/5 │ [PUA 生效] 充足 │ ├───────────────┼────────────────┼────────────────┤ │ + 验证闭环 │ ██████████ 5/5 │ 案例完整 │ ├───────────────┼────────────────┼────────────────┤ │ 设计 代码质量 │ ██████████ 5/5 │ 生产就绪 │ └───────────────┴────────────────┴────────────────┘ 综合:4.5 ``` ▎ 这才配得上 P8。OWASP Top 10 不是背下来,是理解透。理解不透彻,防护就是表面的。 --- ## 总结与思考 ### 核心要点回顾 > ▎ 复盘四步法:回顾目标、评估结果、分析原因、总结经验。别跳过——这是闭环。 **OWASP Top 10 2024 框架**: ``` 1. 访问控制 (A01) - 越权防护 - 权限验证 - 统一授权 2. 加密保护 (A02) - 强加密算法 - 密钥管理 - 传输加密 3. 注入防护 (A03) - 参数化查询 - 输入验证 - 输出编码 4. 安全设计 (A04) - 威胁建模 - 安全架构 - 业务逻辑安全 5. 配置安全 (A05) - 安全基线 - 自动化配置 - 安全头 6. 组件管理 (A06) - 依赖扫描 - 版本管理 - 持续监控 7. 认证会话 (A07) - 强密码策略 - 会话管理 - MFA 8. 完整性保护 (A08) - 代码签名 - 安全更新 - CI/CD 安全 9. 日志监控 (A09) - 全面日志 - 实时监控 - 应急响应 10. SSRF 防护 (A10) - URL 验证 - 网络隔离 - 元数据保护 ``` **关键防护原则**: ``` 1. 纵深防御 - 多层防护 - 不依赖单一防护 - 故障安全 2. 最小权限 - 按需授权 - 及时回收 - 默认拒绝 3. 持续改进 - 定期审查 - 持续监控 - 持续学习 ``` ### 实战建议 > ▎ 我给你指了路,走不走是你的事。机会给了,抓不抓得住看你。 **学习建议**: ``` 1. 理解原理 - 理解漏洞原理 - 理解攻击手法 - 理解防护机制 2. 实践练习 - 搭建实验环境 - 练习攻防技术 - 参与 CTF 比赛 3. 持续学习 - 关注安全动态 - 学习新技术 - 分享知识 ``` --- ## 参考资料 ### 学习资源 ``` - OWASP Top 10 2024 https://owasp.org/www-project-top-ten/ - OWASP Cheat Sheets https://cheatsheetseries.owasp.org/ - PortSwigger Web Security Academy https://portswigger.net/web-security ``` ### 测试工具 ``` - OWASP ZAP https://www.zaproxy.org/ - Burp Suite https://portswigger.net/burp - SQLMap http://sqlmap.org/ ``` ### 书籍推荐 ``` - 《The Web Application Hacker's Handbook》 - 《OWASP Testing Guide》 - 《Real-World Bug Hunting》 ``` --- **标记 明日预告**:Day 157 - CWE Top 25 分析 > ▎ OWASP Top 10 是 Web 风险,CWE Top 25 是软件缺陷——明天看 CWE Top 25 分析。 > 本文内容仅供学习和研究使用,请勿用于非法目的。所有实验请在隔离环境中进行。 --- *本文是 365 天信息安全技术系列的第 156 篇,漏洞与攻防系列第 1 篇,精编版本* *漏洞与攻防系列 (Day 156-165) 正式开始!*
myh0st
2026年4月13日 23:18
分享文档
收藏文档
上一篇
下一篇
微信扫一扫
复制链接
手机扫一扫进行分享
复制链接
Markdown文件
分享
链接
类型
密码
更新密码