Python实战：构建信息安全风险评估模型，实现自动化风险量化

1. 项目概述：从零构建一个实用的风险评估脚本

在信息安全领域，风险评估是几乎所有工作的起点。无论是做等保测评、安全运维，还是规划安全预算，你都得先搞清楚：我们到底有哪些家当（资产）？这些家当面临哪些威胁？万一出事，损失有多大？最后，哪些风险需要优先处理？这些问题，光靠拍脑袋是没用的，需要一个结构化的方法来量化。

很多朋友一听到“风险评估模型”，就觉得是咨询公司或者大厂安全部门才玩得转的复杂东西，需要专门的商业软件。其实不然，其核心逻辑非常清晰：识别资产 -> 评估资产价值 -> 识别威胁与脆弱性 -> 计算风险值 -> 给出处置建议。这个逻辑链条，完全可以用我们最熟悉的Python来实现自动化，变成一个轻量级、可定制、能反复使用的脚本工具。

我这次要分享的，就是如何用Python，从零开始搭建一个简单的信息安全风险评估模型。这个模型的核心是计算两个关键指标：资产价值和风险值。资产价值决定了“东西有多重要”，风险值则量化了“出事的可能性与后果”。最终，脚本会输出一份结构化的报告，告诉你哪些风险是“高危”，必须立刻处理；哪些可以“观察”，后续跟进。

这个项目特别适合以下几类朋友：

1. 信息安全工程师或运维人员：需要定期对负责的系统进行风险评估，但不想每次都手动填Excel表格。
2. 开发人员或项目负责人：在项目上线前，想快速评估一下应用的安全风险，做到心中有数。
3. 对安全感兴趣的Python学习者：想找一个有明确业务场景、能串联多个Python知识点的实战项目。
4. 备考相关认证（如软考信息安全工程师）的同学：通过动手实现，可以深刻理解风险评估的计算过程，比死记硬背公式有效得多。

整个实现过程，我们会用到Python的基础数据结构、文件操作、简单的数学计算，以及报告生成。不需要复杂的机器学习库，重点在于逻辑的严谨性和脚本的实用性。下面，我就带你一步步拆解思路，并把代码实现、参数定义、常见坑点都讲清楚。

2. 风险评估模型的核心逻辑拆解

在动手写代码之前，我们必须把模型的计算逻辑彻底搞明白。一个简易但完整的信息安全风险评估模型，通常遵循以下流程，这也是我们代码结构的蓝图：

信息收集 -> 资产赋值 -> 威胁分析 -> 脆弱性分析 -> 风险计算 -> 结果输出。

2.1 核心概念定义

我们的模型围绕几个核心概念展开，理解它们的定义和关系至关重要：

1. 资产：在信息安全语境下，资产是指对组织具有价值的任何信息、软件、硬件、服务、人员等。例如：客户数据库服务器、官网Web应用、源代码仓库、门禁系统。
2. 资产价值：并非指资产的市场价格，而是指其保密性、完整性、可用性三个安全属性遭到破坏时，对组织造成的潜在影响或损失程度。通常用一个综合的数值来表示。
3. 威胁：可能导致对系统或组织损害的不期望事件发生的潜在原因。例如：黑客攻击、内部人员误操作、硬件故障、自然灾害。
4. 脆弱性：资产自身存在的、可能被威胁所利用的弱点或缺陷。例如：服务器存在未修复的高危漏洞、员工使用弱口令、机房没有备用电源。
5. 风险：特定的威胁利用资产的一项或多项脆弱性，导致安全事件发生，从而对资产造成损害的可能性及其影响的组合。风险是我们要计算的最终目标。

注意：这里采用的是经典的“资产-威胁-脆弱性”风险模型。在实际操作中，我们通常不会漫无边际地列举所有威胁和脆弱性，而是针对具体的资产，分析它可能面临的主要威胁和已存在的脆弱性。这能让评估更聚焦、更高效。

2.2 风险值计算公式

风险值如何量化？最常用的一个简化公式是：

风险值 = 资产价值 × 威胁发生的可能性 × 脆弱性被利用的严重程度

这个公式直观地体现了风险的三要素：资产本身的价值（影响）、坏事发生的概率（可能性）、以及坏事能造成多大破坏（严重性）。

• 资产价值：我们需要先计算出来，是一个1-5或1-10的等级值。
• 威胁可能性：威胁事件发生的频率或概率，同样用1-5等级表示。例如，1代表“几乎不可能”，5代表“几乎肯定发生”。
• 脆弱性严重程度：该脆弱性如果被成功利用，会导致多严重的后果，用1-5等级表示。例如，1代表“轻微影响”，5代表“灾难性影响”。

将这三个等级值相乘，得到的就是一个量化的风险值。这个值越大，代表风险越高。

2.3 资产价值计算公式

资产价值怎么算？我们采用对保密性、完整性、可用性分别赋值再综合的方法：

资产价值 = (保密性赋值 + 完整性赋值 + 可用性赋值) / 3

或者采用加权平均，如果某个属性对特定资产更重要的话。每个属性（C/I/A）也使用1-5的等级进行赋值：

• 5-非常高：破坏会导致灾难性后果。
• 4-高：破坏会导致严重损失。
• 3-中：破坏会导致中度损失。
• 2-低：破坏会导致轻微损失。
• 1-可忽略：破坏后果可忽略。

例如，对于“客户数据库”：

• 保密性：5（数据泄露后果严重）
• 完整性：4（数据被篡改影响业务）
• 可用性：3（短暂中断可恢复）
• 资产价值 = (5+4+3)/3 = 4.0

有了这些理论基础，我们就可以开始设计程序的数据结构和流程了。

3. 模型设计与数据结构规划

代码的骨架源于清晰的逻辑设计。我们需要规划好如何存储资产、威胁、脆弱性这些信息，以及它们之间的关联关系。

3.1 使用字典和列表构建核心数据

Python的字典和列表非常适合用来表示这种结构化的评估数据。我建议按以下方式组织：

# 资产列表，每个资产是一个字典 assets = [ { “id”: “AST-001”, “name”: “官网Web服务器”, “description”: “承载公司官网和产品展示页面，运行在Nginx上。”, “confidentiality”: 3, # 保密性赋值 “integrity”: 4, # 完整性赋值 “availability”: 5, # 可用性赋值 “value”: 0.0 # 待计算，初始为0 }, { “id”: “AST-002”, “name”: “核心业务数据库”, “description”: “存储所有用户订单和交易数据，MySQL主从架构。”, “confidentiality”: 5, “integrity”: 5, “availability”: 4, “value”: 0.0 } ] # 威胁库，可以预定义一些常见威胁 threat_library = [ {“id”: “T-01”, “name”: “DDoS攻击”, “description”: “通过海量流量耗尽目标带宽或资源。”}, {“id”: “T-02”, “name”: “SQL注入”, “description”: “攻击者利用Web应用漏洞执行恶意SQL语句。”}, {“id”: “T-03”, “name”: “内部人员误操作”, “description”: “授权员工无意中删除或修改关键数据。”}, {“id”: “T-04”, “name”: “硬件故障”, “description”: “服务器硬盘、内存等物理部件损坏。”} ] # 脆弱性库，同样可以预定义 vulnerability_library = [ {“id”: “V-01”, “name”: “未授权访问”, “description”: “系统存在无需认证即可访问的接口或页面。”}, {“id”: “V-02”, “name”: “弱口令”, “description”: “系统账户使用了简单、易猜测的密码。”}, {“id”: “V-03”, “name”: “未安装关键安全补丁”, “description”: “操作系统或应用存在已知高危漏洞且未修复。”}, {“id”: “V-04”, “name”: “备份缺失或失效”, “description”: “没有定期备份或备份数据无法成功恢复。”} ]

3.2 风险评估记录表

这是整个模型的核心表，它把资产、威胁、脆弱性关联起来，并记录评估的等级和计算结果。

# 风险评估记录，每个记录代表一个具体的“资产-威胁-脆弱性”组合 risk_assessments = [ { “id”: “RA-001”, “asset_id”: “AST-001”, # 关联资产ID “threat_id”: “T-01”, # 关联威胁ID “vulnerability_id”: “V-03”, # 关联脆弱性ID “likelihood”: 4, # 威胁可能性 (1-5) “severity”: 4, # 脆弱性严重程度 (1-5) “risk_value”: 0.0 # 待计算的风险值 }, { “id”: “RA-002”, “asset_id”: “AST-002”, “threat_id”: “T-02”, “vulnerability_id”: “V-02”, “likelihood”: 3, “severity”: 5, “risk_value”: 0.0 } ]

实操心得：在项目初期，强烈建议像上面这样，用硬编码的方式在脚本里定义一些示例数据。这有两大好处：第一，可以立即开始编写和测试核心计算逻辑，不用等待复杂的数据输入功能；第二，这些示例数据本身就是一份很好的文档，能让你和后续的协作者快速理解数据结构。等核心逻辑跑通后，再扩展为从文件读取或交互式输入。

3.3 程序主流程设计

我们的脚本将按照以下步骤运行：

1. 初始化：加载或定义资产、威胁、脆弱性数据，以及风险评估记录。
2. 计算资产价值：遍历资产列表，根据C/I/A赋值计算每个资产的综合价值。
3. 计算风险值：遍历风险评估记录，根据公式（资产价值 × 可能性 × 严重性）计算每条记录的风险值。
4. 风险等级判定：根据计算出的风险值，将其划分为“高”、“中”、“低”等不同等级。
5. 生成报告：将资产列表、风险清单（按风险值排序）等结果输出到控制台或文件。

接下来，我们就进入具体的代码实现环节。

4. 分步代码实现与详解

让我们把上面的设计变成可运行的代码。我会分函数讲解，确保每一部分你都清楚其作用。

4.1 数据准备与初始化

首先，我们把之前设计的数据结构放到代码里，并写一个初始化函数。为了后续扩展，我们会把数据定义和初始化分开。

# risk_assessment_model.py def init_data(): “”“初始化示例数据。”“” assets = [ {“id”: “AST-001”, “name”: “官网Web服务器”, “description”: “承载公司官网”, “confidentiality”: 3, “integrity”: 4, “availability”: 5, “value”: 0.0}, {“id”: “AST-002”, “name”: “核心业务数据库”, “description”: “存储用户订单数据”, “confidentiality”: 5, “integrity”: 5, “availability”: 4, “value”: 0.0}, {“id”: “AST-003”, “name”: “内部邮件系统”, “description”: “员工内部通信”, “confidentiality”: 4, “integrity”: 3, “availability”: 3, “value”: 0.0} ] threat_library = [ {“id”: “T-01”, “name”: “DDoS攻击”, “description”: “耗尽目标资源。”}, {“id”: “T-02”, “name”: “SQL注入”, “description”: “利用漏洞执行恶意SQL。”}, {“id”: “T-03”, “name”: “内部人员误操作”, “description”: “员工无意删除数据。”}, {“id”: “T-04”, “name”: “硬件故障”, “description”: “物理部件损坏。”} ] vulnerability_library = [ {“id”: “V-01”, “name”: “未授权访问”, “description”: “存在无需认证的接口。”}, {“id”: “V-02”, “name”: “弱口令”, “description”: “使用简单密码。”}, {“id”: “V-03”, “name”: “未安装关键补丁”, “description”: “存在已知高危漏洞。”}, {“id”: “V-04”, “name”: “备份缺失”, “description”: “无有效备份。”} ] risk_assessments = [ {“id”: “RA-001”, “asset_id”: “AST-001”, “threat_id”: “T-01”, “vulnerability_id”: “V-03”, “likelihood”: 4, “severity”: 4, “risk_value”: 0.0}, {“id”: “RA-002”, “asset_id”: “AST-002”, “threat_id”: “T-02”, “vulnerability_id”: “V-02”, “likelihood”: 3, “severity”: 5, “risk_value”: 0.0}, {“id”: “RA-003”, “asset_id”: “AST-002”, “threat_id”: “T-04”, “vulnerability_id”: “V-04”, “likelihood”: 2, “severity”: 5, “risk_value”: 0.0}, {“id”: “RA-004”, “asset_id”: “AST-003”, “threat_id”: “T-03”, “vulnerability_id”: “V-01”, “likelihood”: 3, “severity”: 3, “risk_value”: 0.0} ] return assets, threat_library, vulnerability_library, risk_assessments

4.2 核心计算函数实现

接下来是实现两个核心计算函数：calculate_asset_value和calculate_risk_value。

def calculate_asset_value(asset): “”“计算单个资产的价值。 公式: 资产价值 = (保密性 + 完整性 + 可用性) / 3 保留一位小数。 ”“” c = asset.get(“confidentiality”, 1) i = asset.get(“integrity”, 1) a = asset.get(“availability”, 1) # 简单平均计算，也可以根据业务需求改为加权平均 value = round((c + i + a) / 3.0, 1) return value def calculate_all_asset_values(assets): “”“计算所有资产的价值，并更新到资产字典中。”“” for asset in assets: asset[“value”] = calculate_asset_value(asset) print(“[INFO] 所有资产价值计算完成。”) def calculate_risk_value(risk_assessment, asset_value): “”“计算单条风险评估记录的风险值。 公式: 风险值 = 资产价值 × 威胁可能性 × 脆弱性严重程度 ”“” likelihood = risk_assessment.get(“likelihood”, 1) severity = risk_assessment.get(“severity”, 1) risk_val = asset_value * likelihood * severity return round(risk_val, 2) # 保留两位小数 def calculate_all_risk_values(assets, risk_assessments): “”“计算所有风险评估记录的风险值。 需要先根据 asset_id 找到对应的资产价值。 ”“” # 创建一个资产ID到资产价值的映射字典，方便快速查找 asset_value_map = {asset[“id”]: asset[“value”] for asset in assets} for ra in risk_assessments: asset_id = ra[“asset_id”] asset_value = asset_value_map.get(asset_id, 1.0) # 如果找不到，默认给1.0 ra[“risk_value”] = calculate_risk_value(ra, asset_value) print(“[INFO] 所有风险值计算完成。”)

注意事项：在calculate_all_risk_values函数中，我创建了一个asset_value_map映射字典。这是一个非常实用的性能优化技巧。如果不这样做，你就需要在双层循环中遍历资产列表来查找每个risk_assessment对应的资产，当数据量稍大时（比如几百条记录），效率会非常低。用字典（哈希表）实现O(1)时间复杂度的查找，是处理这类关联查询的常规操作。

4.3 风险等级判定与报告生成

计算出的风险值是一个数字，我们需要将其转化为更直观的风险等级。

def determine_risk_level(risk_value): “”“根据风险值确定风险等级。 划分阈值可以根据实际业务调整。这里是一个示例： 高风险: risk_value >= 50 中风险: 20 <= risk_value < 50 低风险: risk_value < 20 ”“” if risk_value >= 50: return “高” elif risk_value >= 20: return “中” else: return “低” def generate_report(assets, threat_lib, vul_lib, risk_assessments): “”“生成并打印风险评估报告。”“” print(“\n” + “=”*60) print(“信息安全风险评估报告”) print(“=”*60) # 1. 资产清单 print(“\n1. 资产清单与价值评估：”) print(“-”*40) for asset in assets: level = “高” if asset[“value”] >= 4.0 else (“中” if asset[“value”] >= 2.5 else “低”) print(f“ID: {asset[‘id’]:<10} 名称: {asset[‘name’]:<20} 价值: {asset[‘value’]:<4} (等级: {level})”) # 2. 风险清单（按风险值降序排序） print(“\n2. 风险清单（按风险值降序排序）：”) print(“-”*80) # 排序前，为每条记录补充详细信息并确定等级 detailed_risks = [] for ra in risk_assessments: asset = next((a for a in assets if a[“id”] == ra[“asset_id”]), {“name”: “未知资产”}) threat = next((t for t in threat_lib if t[“id”] == ra[“threat_id”]), {“name”: “未知威胁”}) vul = next((v for v in vul_lib if v[“id”] == ra[“vulnerability_id”]), {“name”: “未知脆弱性”}) risk_level = determine_risk_level(ra[“risk_value”]) detailed_risks.append({ “id”: ra[“id”], “asset_name”: asset[“name”], “threat_name”: threat[“name”], “vul_name”: vul[“name”], “likelihood”: ra[“likelihood”], “severity”: ra[“severity”], “risk_value”: ra[“risk_value”], “risk_level”: risk_level }) # 按风险值降序排序 detailed_risks.sort(key=lambda x: x[“risk_value”], reverse=True) for dr in detailed_risks: print(f“ID: {dr[‘id’]:<8} | 资产: {dr[‘asset_name’]:<15} | 威胁: {dr[‘threat_name’]:<12} | 脆弱性: {dr[‘vul_name’]:<10}”) print(f“ 可能性: {dr[‘likelihood’]} | 严重性: {dr[‘severity’]} | 风险值: {dr[‘risk_value’]:<6} | 风险等级: 【{dr[‘risk_level’]}】”) print(“ ” + “-”*70) # 3. 风险统计 print(“\n3. 风险等级统计：”) print(“-”*40) level_count = {“高”: 0, “中”: 0, “低”: 0} for dr in detailed_risks: level_count[dr[“risk_level”]] += 1 for level, count in level_count.items(): print(f“{level}风险数量: {count}”) # 4. 最高风险项提示 if detailed_risks: top_risk = detailed_risks[0] print(f“\n[!] 最高风险项: {top_risk[‘asset_name’]} 面临的 {top_risk[‘threat_name’]} 威胁 (风险值: {top_risk[‘risk_value’]})， 建议优先处置。”)

4.4 主函数与执行

最后，我们把所有函数串联起来，形成一个完整的脚本。

def main(): “”“主函数，执行风险评估全流程。”“” print(“开始执行信息安全风险评估模型...”) # 1. 初始化数据 assets, threat_lib, vul_lib, risk_assessments = init_data() print(f“[INFO] 数据加载完成。资产数: {len(assets)}， 威胁数: {len(threat_lib)}， 脆弱性数: {len(vul_lib)}， 评估记录数: {len(risk_assessments)}”) # 2. 计算所有资产价值 calculate_all_asset_values(assets) # 3. 计算所有风险值 calculate_all_risk_values(assets, risk_assessments) # 4. 生成并输出报告 generate_report(assets, threat_lib, vul_lib, risk_assessments) print(“\n风险评估报告生成完毕。”) if __name__ == “__main__”: main()

现在，在命令行运行python risk_assessment_model.py，你就能看到一份完整的风险评估报告输出在控制台了。

5. 模型优化与功能扩展

基础的模型跑通了，但这只是个开始。一个真正实用的工具还需要考虑更多。下面分享几个关键的优化和扩展方向，这也是体现你项目深度的部分。

5.1 数据持久化：从代码到文件

硬编码数据只适用于演示。实际使用时，我们需要从文件（如CSV、JSON）读取数据，并将结果保存下来。

使用JSON文件存储数据： 创建一个data.json文件来存储所有数据。

{ “assets”: [ {“id”: “AST-001”, “name”: “官网Web服务器”, “description”: “承载公司官网”, “confidentiality”: 3, “integrity”: 4, “availability”: 5} ], “threats”: [ {“id”: “T-01”, “name”: “DDoS攻击”, “description”: “耗尽目标资源。”} ], “vulnerabilities”: [ {“id”: “V-01”, “name”: “未授权访问”, “description”: “存在无需认证的接口。”} ], “assessments”: [ {“id”: “RA-001”, “asset_id”: “AST-001”, “threat_id”: “T-01”, “vulnerability_id”: “V-01”, “likelihood”: 4, “severity”: 4} ] }

然后，修改初始化函数，从JSON文件加载：

import json def load_data_from_json(filepath): “”“从JSON文件加载数据。”“” try: with open(filepath, ‘r’, encoding=‘utf-8’) as f: data = json.load(f) return data.get(“assets”, []), data.get(“threats”, []), data.get(“vulnerabilities”, []), data.get(“assessments”, []) except FileNotFoundError: print(f“[ERROR] 数据文件 {filepath} 未找到，将使用空数据。”) return [], [], [], [] except json.JSONDecodeError: print(f“[ERROR] 数据文件 {filepath} 格式错误。”) return [], [], [], []

将报告输出到文件： 同样，我们可以轻松地将generate_report函数输出的内容写入到一个文本文件中。

def generate_report_to_file(assets, threat_lib, vul_lib, risk_assessments, output_file=“risk_report.txt”): “”“生成风险评估报告并保存到文件。”“” import sys original_stdout = sys.stdout with open(output_file, ‘w’, encoding=‘utf-8’) as f: sys.stdout = f # 重定向标准输出到文件 generate_report(assets, threat_lib, vul_lib, risk_assessments) sys.stdout = original_stdout # 恢复标准输出 print(f“[INFO] 风险评估报告已保存至: {output_file}”)

5.2 交互式数据录入

对于偶尔的、小规模的评估，一个命令行交互界面比编辑JSON文件更友好。我们可以用input()函数实现。

def interactive_input(): “”“通过命令行交互式输入一条风险评估记录。”“” print(“\n--- 开始交互式风险评估录入 ---”) asset_id = input(“请输入资产ID (例如 AST-001): “).strip() threat_id = input(“请输入威胁ID (例如 T-01): “).strip() vul_id = input(“请输入脆弱性ID (例如 V-01): “).strip() try: likelihood = int(input(“请输入威胁可能性 (1-5): “).strip()) severity = int(input(“请输入脆弱性严重程度 (1-5): “).strip()) # 确保输入在有效范围 likelihood = max(1, min(5, likelihood)) severity = max(1, min(5, severity)) except ValueError: print(“[WARNING] 输入非数字，将使用默认值1。”) likelihood = severity = 1 new_assessment = { “id”: f“RA-{len(risk_assessments)+1:03d}”, # 自动生成ID “asset_id”: asset_id, “threat_id”: threat_id, “vulnerability_id”: vul_id, “likelihood”: likelihood, “severity”: severity, “risk_value”: 0.0 } print(f“已创建评估记录: {new_assessment}”) return new_assessment

在主函数中，你可以添加一个选项，让用户选择是加载文件还是交互输入。

5.3 引入加权计算与矩阵法

我们之前的资产价值计算是简单平均，风险计算是直接相乘。在实际中，可能需要更精细的模型。

资产价值加权计算： 对于不同的资产，CIA三性的重要性可能不同。比如，对于数据库，保密性权重要高；对于官网，可用性权重要高。

def calculate_asset_value_weighted(asset, weights={“confidentiality”: 0.4, “integrity”: 0.3, “availability”: 0.3}): “”“使用加权平均计算资产价值。”“” c = asset.get(“confidentiality”, 1) * weights.get(“confidentiality”, 0.33) i = asset.get(“integrity”, 1) * weights.get(“integrity”, 0.33) a = asset.get(“availability”, 1) * weights.get(“availability”, 0.34) value = round(c + i + a, 1) # 加权和 return value

风险矩阵法： 更专业的做法是使用风险矩阵。我们预先定义一个5x5的矩阵，将可能性和严重性的等级组合映射到风险等级。

# 定义一个风险矩阵， matrix[可能性][严重性] -> 风险等级 RISK_MATRIX = { 1: {1: “低”, 2: “低”, 3: “低”, 4: “中”, 5: “中”}, 2: {1: “低”, 2: “低”, 3: “中”, 4: “中”, 5: “高”}, 3: {1: “低”, 2: “中”, 3: “中”, 4: “高”, 5: “高”}, 4: {1: “中”, 2: “中”, 3: “高”, 4: “高”, 5: “高”}, 5: {1: “中”, 2: “高”, 3: “高”, 4: “高”, 5: “高”} } def determine_risk_level_by_matrix(likelihood, severity): “”“使用风险矩阵确定等级。”“” return RISK_MATRIX.get(likelihood, {}).get(severity, “未知”)

然后在计算风险值时，可以先通过矩阵得到等级，再结合资产价值进行综合判断。例如，高价值资产的“中”风险可能需要提升为“高”风险。

5.4 可视化输出

文字报告不够直观？我们可以用matplotlib库生成图表。

# 首先安装: pip install matplotlib import matplotlib.pyplot as plt def plot_risk_distribution(detailed_risks, output_image=“risk_distribution.png”): “”“绘制风险分布柱状图。”“” if not detailed_risks: print(“[INFO] 无风险数据，无法生成图表。”) return # 按风险等级分组计数 levels = [“高”, “中”, “低”] counts = [0, 0, 0] for dr in detailed_risks: if dr[“risk_level”] == “高”: counts[0] += 1 elif dr[“risk_level”] == “中”: counts[1] += 1 else: counts[2] += 1 # 创建图表 plt.figure(figsize=(8, 5)) bars = plt.bar(levels, counts, color=[‘#ff6b6b’, ‘#ffd93d’, ‘#6bcf7f’]) # 红，黄，绿 plt.title(‘信息安全风险等级分布’, fontsize=14) plt.xlabel(‘风险等级’, fontsize=12) plt.ylabel(‘数量’, fontsize=12) # 在柱子上方显示数量 for bar, count in zip(bars, counts): height = bar.get_height() plt.text(bar.get_x() + bar.get_width()/2., height + 0.1, f‘{count}’, ha=‘center’, va=‘bottom’) plt.tight_layout() plt.savefig(output_image, dpi=300) print(f“[INFO] 风险分布图已保存至: {output_image}”) # plt.show() # 如果在桌面环境，可以显示图表

在主函数中调用plot_risk_distribution(detailed_risks)，就能生成一张直观的风险分布图。

6. 常见问题、排查技巧与避坑指南

在实际编写和运行这个脚本的过程中，你肯定会遇到一些问题。下面是我总结的一些常见坑点和解决思路。

6.1 数据关联错误与查找失败

问题：在generate_report函数中，使用next()查找资产、威胁、脆弱性信息时，如果ID不匹配或数据缺失，会返回None或导致StopIteration异常，进而引发KeyError（比如尝试访问asset[“name”]时asset是None）。

解决方案：

1. 使用带默认值的next()：如代码所示，next((a for a in assets if a[“id”] == ra[“asset_id”]), {“name”: “未知资产”})。这样即使找不到，也会返回一个包含默认值的字典，避免程序崩溃。
2. 增加数据完整性校验：在计算风险值之前，写一个校验函数，检查所有risk_assessments中的asset_id、threat_id、vulnerability_id是否在对应的库中存在。

   def validate_data(assets, threats, vulns, assessments): asset_ids = {a[“id”] for a in assets} threat_ids = {t[“id”] for t in threats} vuln_ids = {v[“id”] for v in vulns} errors = [] for ra in assessments: if ra[“asset_id”] not in asset_ids: errors.append(f“评估记录 {ra[‘id’]} 引用了不存在的资产ID: {ra[‘asset_id’]}”) # 同理检查threat_id和vulnerability_id if errors: for err in errors: print(f“[ERROR] {err}”) return False return True

6.2 数值范围与有效性检查

问题：用户在交互式输入或编辑JSON文件时，可能输入超出1-5范围的值，或者非数字，导致计算结果异常（比如风险值异常大或小）。

解决方案：

1. 在输入环节限制：如interactive_input函数中，使用max(1, min(5, likelihood))进行钳制。
2. 在计算环节容错：在calculate_asset_value和calculate_risk_value函数中，使用.get(key, default_value)并提供合理的默认值（如1）。
3. 添加断言或日志：在关键计算后，可以加入断言或打印日志，帮助调试。

   def calculate_risk_value(risk_assessment, asset_value): likelihood = risk_assessment.get(“likelihood”, 1) severity = risk_assessment.get(“severity”, 1) # 可选：记录异常值 if not (1 <= likelihood <= 5) or not (1 <= severity <= 5): print(f“[WARNING] 记录 {risk_assessment.get(‘id’)} 的可能性或严重性值异常: L={likelihood}, S={severity}”) risk_val = asset_value * likelihood * severity return round(risk_val, 2)

6.3 性能问题与优化

问题：当资产、威胁、评估记录数量达到上千条时，我们报告生成函数中的嵌套循环（在detailed_risks的for循环里又用了next遍历查找）可能会变得较慢。

解决方案：

1. 预构建映射字典：这是最有效的优化。我们已经在calculate_all_risk_values里为资产价值做了。在generate_report里，同样可以为威胁和脆弱性构建映射。

   threat_map = {t[“id”]: t for t in threat_lib} vul_map = {v[“id”]: v for v in vul_lib} asset_map = {a[“id”]: a for a in assets} # 如果还没构建的话 for ra in risk_assessments: asset = asset_map.get(ra[“asset_id”], {“name”: “未知”}) threat = threat_map.get(ra[“threat_id”], {“name”: “未知”}) vul = vul_map.get(ra[“vulnerability_id”], {“name”: “未知”}) # ... 后续处理

   这样就将O(n²)的查找复杂度降为了O(1)。
2. 考虑使用Pandas：如果数据量非常大，且需要复杂的分析和报表，pandas库是更好的选择。它提供了高效的DataFrame操作，但会引入额外的依赖。

6.4 报告可读性与定制化

问题：控制台输出的报告格式可能不够美观，或者领导需要特定格式（如Word、PDF）。

解决方案：

1. 美化控制台输出：使用tabulate库可以轻松打印出漂亮的表格。

   # pip install tabulate from tabulate import tabulate table_data = [[dr[‘id’], dr[‘asset_name’], dr[‘risk_value’], dr[‘risk_level’]] for dr in detailed_risks] headers = [“ID”, “资产”, “风险值”, “风险等级”] print(tabulate(table_data, headers=headers, tablefmt=“grid”))

2. 生成HTML/Word/PDF报告：
   • HTML：可以用Jinja2模板引擎，将数据填充到HTML模板中，生成网页版报告。
   • Word：使用python-docx库可以编程创建和编辑Word文档。
   • PDF：reportlab库功能强大但稍复杂；或者先生成HTML，再用wkhtmltopdf转换。

6.5 模型本身的局限性认知

重要提醒：我们这个Python实现的是一个简化版的定性/半定量风险评估模型。它非常适合用于快速筛查、内部讨论、风险排序和意识提升。但在正式的、需要审计的场合（如等保测评），通常需要遵循更严格的标准（如ISO 27005、NIST SP 800-30），使用更复杂的定量分析方法和专业的工具。

我们这个脚本的价值在于：

• 快速原型：帮助你在几分钟内对一个简单的系统环境完成风险初筛。
• 理解过程：通过代码彻底弄懂风险评估每个步骤在做什么。
• 定制化基础：你可以基于这个框架，轻松地修改计算公式、添加新的属性（如“合规性影响”）、或者集成到其他自动化流程中。

记住，工具是辅助决策的，而不是替代专业判断。最终的风险处置优先级，还需要结合业务上下文、成本效益分析来综合决定。这个脚本输出的结果，是你与业务、技术同事沟通时一份非常直观的“数据支撑”。