@ohos-graphics/stability-code-review 0.1.0

package/references/RULE_INDEX.md

@@ -0,0 +1,101 @@
+# 稳定性规则总索引
+
+本文件列出所有可用的稳定性规则及其配置信息。
+
+## 规则统计
+
+| 大类 | 规则数量 | 严重程度分布 |
+|------|----------|--------------|
+| 异常处理 | 3 | HIGH: 1, MEDIUM: 2 |
+| 并发稳定性 | 5 | HIGH: 4, MEDIUM: 1 |
+| 性能稳定性 | 2 | HIGH: 2 |
+| 资源管理 | 7 | CRITICAL: 2, HIGH: 3, MEDIUM: 2 |
+| 初始化顺序 | 1 | MEDIUM: 1 |
+| 边界条件 | 18 | CRITICAL: 4, HIGH: 10, MEDIUM: 4 |
+| 生命周期 | 2 | CRITICAL: 1, HIGH: 1 |
+| 内存稳定性 | 7 | CRITICAL: 5, HIGH: 2 |
+| 图形稳定性 | 12 | HIGH: 12 |
+| **总计** | **57** | CRITICAL: 12, HIGH: 35, MEDIUM: 10 |
+
+---
+
+## 规则列表
+
+### CRITICAL (12)
+
+| 规则 ID | 名称 | 分类 | 描述 |
+|---------|------|------|------|
+| StabilityCodeReview_ResourceManagement_003 | 禁止智能指针get初始化另一个智能指针 | 资源管理 | 智能指针get()返回裸指针初始化另一个智能指针导致 double-free |
+| StabilityCodeReview_ResourceManagement_007 | 智能指针与裸指针混用 | 资源管理 | 智能指针与裸指针混用导致生命周期管理混乱 |
+| StabilityCodeReview_BoundaryCondition_001 | Parcel数据不可作为循环或递归条件 | 边界条件 | Parcel 数据作为循环条件可能导致无限循环或拒绝服务 |
+| StabilityCodeReview_BoundaryCondition_002 | Parcel数据不可直接作为数组下标 | 边界条件 | Parcel 数据直接作为数组下标可能导致内存越界访问 |
+| StabilityCodeReview_BoundaryCondition_006 | 除法和模运算需做除零保护 | 边界条件 | 除法和模运算未做除零保护可能导致 SIGFPE 崩溃 |
+| StabilityCodeReview_BoundaryCondition_016 | 内存操作越界风险 | 边界条件 | 外部可控参数进行内存操作时未做边界校验可能导致内存越界 |
+| StabilityCodeReview_Lifecycle_001 | 返回引用的函数返回局部变量 | 生命周期 | 函数返回局部变量的引用导致悬垂引用和 use-after-free |
+| StabilityCodeReview_MemoryStability_001 | 内存分配失败判空检查 | 内存稳定性 | 内存分配后未检查 nullptr 就直接使用导致空指针解引用 |
+| StabilityCodeReview_MemoryStability_002 | 指针解引用前判空 | 内存稳定性 | 指针未判空直接解引用导致空指针解引用崩溃 |
+| StabilityCodeReview_MemoryStability_005 | double-free问题 | 内存稳定性 | 同一指针在多条路径上被释放导致 double-free |
+| StabilityCodeReview_MemoryStability_006 | use-after-free问题 | 内存稳定性 | 指针释放后继续使用导致 use-after-free |
+| StabilityCodeReview_MemoryStability_007 | 函数返回指针未检查NULL | 内存稳定性 | 函数返回空指针后未检查直接解引用导致崩溃 |
+
+### HIGH (35)
+
+| 规则 ID | 名称 | 分类 | 描述 |
+|---------|------|------|------|
+| StabilityCodeReview_ExceptionHandling_003 | 需校验函数返回值 | 异常处理 | 关键函数返回值未校验导致错误处理遗漏 |
+| StabilityCodeReview_ConcurrencyStability_001 | 多线程场景线程安全设计缺失 | 并发稳定性 | 多线程访问共享变量时未做线程安全保护导致数据竞争 |
+| StabilityCodeReview_ConcurrencyStability_002 | 智能指针线程安全问题 | 并发稳定性 | 智能指针引用计数操作非原子性导致线程安全问题 |
+| StabilityCodeReview_ConcurrencyStability_004 | 加锁后返回引用或裸指针问题 | 并发稳定性 | 加锁后返回引用或裸指针导致锁外访问风险 |
+| StabilityCodeReview_ConcurrencyStability_005 | RenderNodeDrawable全局变量写入问题 | 并发稳定性 | RenderNodeDrawable全局变量在多线程场景写入未加锁保护 |
+| StabilityCodeReview_PerformanceStability_001 | 递归条件未考虑充分导致无限递归 | 性能稳定性 | 递归终止条件未充分考虑导致无限递归和栈溢出 |
+| StabilityCodeReview_PerformanceStability_002 | 间接递归风险 | 性能稳定性 | 函数间相互调用形成的间接递归可能导致栈溢出 |
+| StabilityCodeReview_ResourceManagement_001 | 反序列化内存泄漏 | 资源管理 | 反序列化过程中的内存泄漏风险 |
+| StabilityCodeReview_ResourceManagement_002 | dlopen需配对dlclose | 赿源管理 | dlopen 后未配对调用 dlclose 导致动态库资源泄漏 |
+| StabilityCodeReview_ResourceManagement_005 | 文件描述符泄漏 | 资源管理 | open/socket/epoll 等文件描述符在错误路径上未关闭 |
+| StabilityCodeReview_BoundaryCondition_003 | Parcel数据不可直接作为内存申请大小 | 边界条件 | Parcel 数据直接作为内存申请大小可能导致 OOM 或整数溢出 |
+| StabilityCodeReview_BoundaryCondition_004 | 容器size增长的对外接口应限制上限 | 边界条件 | 容器 size 增长的对外接口未限制上限可能导致 OOM |
+| StabilityCodeReview_BoundaryCondition_007 | Parcel序列化和反序列化必须匹配 | 边界条件 | Parcel 序列化和反序列化不匹配导致数据处理错误 |
+| StabilityCodeReview_BoundaryCondition_008 | 容器erase后需正确更新迭代器 | 边界条件 | 容器 erase 后未正确更新迭代器导致迭代器失效 |
+| StabilityCodeReview_BoundaryCondition_009 | 外部数据类型转换需范围检查 | 边界条件 | 外部数据类型转换未做范围检查导致数据截断或溢出 |
+| StabilityCodeReview_BoundaryCondition_010 | 容器find返回迭代器需校验有效性 | 边界条件 | 容器 find 返回迭代器未校验有效性直接访问导致崩溃 |
+| StabilityCodeReview_BoundaryCondition_011 | 加减乘除运算应避免类型溢出或回绕 | 边界条件 | 加减乘除运算未考虑类型溢出或回绕导致计算错误 |
+| StabilityCodeReview_BoundaryCondition_014 | 类型强制转换未校验，可能导致越界读 | 边界条件 | 类型强制转换未校验范围导致越界读取 |
+| StabilityCodeReview_BoundaryCondition_015 | 数组下标的计算应避免整数回绕导致内存越界访问 | 边界条件 | 数组下标计算发生整数回绕导致内存越界访问 |
+| StabilityCodeReview_BoundaryCondition_018 | JSON解析安全风险 | 边界条件 | JSON 解析过程中的安全风险 |
+| StabilityCodeReview_Lifecycle_002 | 获取临时变量指针 | 生命周期 | 获取临时变量的指针或引用导致悬垂指针 |
+| StabilityCodeReview_MemoryStability_003 | 异常分支内存未及时释放 | 内存稳定性 | 异常分支、早返回路径上分配的内存未及时释放 |
+| StabilityCodeReview_MemoryStability_004 | 多返回路径资源泄漏 | 内存稳定性 | 多返回路径上的内存泄漏风险 |
+| StabilityCodeReview_GraphicsStability_001 | VulkanCleanupHelper引用计数管理 | 图形稳定性 | VulkanCleanupHelper 引用计数管理不当导致资源泄漏 |
+| StabilityCodeReview_GraphicsStability_002 | VulkanCleanUpHelper与SharedContext引用计数混用 | 图形稳定性 | VulkanCleanUpHelper 与 SharedContext 引用计数混用导致资源管理混乱 |
+| StabilityCodeReview_GraphicsStability_003 | RS主线程禁止使用RenderNodeDrawable | 图形稳定性 | RS 主线程使用 RenderNodeDrawable 导致线程安全风险 |
+| StabilityCodeReview_GraphicsStability_004 | RSUniRenderThread禁止访问RenderNode | 图形稳定性 | RSUniRenderThread 访问 RenderNode 导致线程安全风险 |
+| StabilityCodeReview_GraphicsStability_005 | RS主线程禁止GPU Context操作 | 图形稳定性 | RS 主线程执行 GPU Context 操作导致线程安全风险 |
+| StabilityCodeReview_GraphicsStability_006 | Surface/Image跨线程跨Context操作风险 | 图形稳定性 | Surface/Image 跨线程跨 Context 操作导致资源管理混乱 |
+| StabilityCodeReview_GraphicsStability_007 | Surface/Image创建和释放线程一致性 | 图形稳定性 | Surface/Image 创建和释放线程不一致导致资源泄漏 |
+| StabilityCodeReview_GraphicsStability_008 | GetBackendTexture线程限制 | 图形稳定性 | GetBackendTexture 在非创建线程调用导致线程安全风险 |
+| StabilityCodeReview_GraphicsStability_009 | RSRenderNodeMap线程访问限制 | 图形稳定性 | RSRenderNodeMap 在多线程访问未加锁保护 |
+| StabilityCodeReview_GraphicsStability_010 | 回调函数执行进程限制 | 图形稳定性 | 回调函数在错误进程执行导致功能异常 |
+| StabilityCodeReview_GraphicsStability_011 | Vulkan信号量导出fd生命周期管理 | 图形稳定性 | Vulkan 信号量导出 fd 生命周期管理不当导致 fd 泄漏 |
+| StabilityCodeReview_GraphicsStability_012 | SyncFence智能指针缓存管理 | 图形稳定性 | SyncFence 智能指针缓存管理不当导致资源泄漏 |
+
+### MEDIUM (10)
+
+| 规则 ID | 名称 | 分类 | 描述 |
+|---------|------|------|------|
+| StabilityCodeReview_ExceptionHandling_001 | 禁止异常处理机制 | 异常处理 | 使用 C++ 异常处理机制（try/catch/throw）违反编码规范 |
+| StabilityCodeReview_ExceptionHandling_002 | 异常分支应正确处理 | 异常处理 | 异常分支处理不当导致错误传播或状态不一致 |
+| StabilityCodeReview_ConcurrencyStability_003 | std::atomic时序问题 | 并发稳定性 | std::atomic 操作时序问题导致数据竞争 |
+| StabilityCodeReview_ResourceManagement_004 | 谨慎使用static_pointer_cast | 资源管理 | static_pointer_cast 使用不当导致类型安全问题 |
+| StabilityCodeReview_ResourceManagement_006 | JSON对象未关闭泄漏 | 资源管理 | JSON 对象未正确关闭导致资源泄漏 |
+| StabilityCodeReview_InitializationOrder_001 | 类的数据成员需要显式初始化 | 初始化顺序 | 类数据成员未显式初始化导致未定义行为 |
+| StabilityCodeReview_BoundaryCondition_005 | Parcel整数转枚举需校验有效性 | 边界条件 | Parcel 整数转枚举未校验有效性导致无效枚举值 |
+| StabilityCodeReview_BoundaryCondition_012 | 使用json库获取键值内容前应先判断类型是否匹配、键值是否存在 | 边界条件 | 使用 json 库获取键值内容前未判断类型或键值是否存在导致解析失败 |
+| StabilityCodeReview_BoundaryCondition_013 | 使用json库获取键值后，在进行类型转换前应先校验参数类型 | 边界条件 | 使用 json 库获取键值后未校验参数类型导致类型转换失败 |
+| StabilityCodeReview_BoundaryCondition_017 | 返回值类型不匹配风险 | 边界条件 | 返回值类型不匹配导致数据截断或溢出 |
+
+---
+
+## 规则模板与开发指南
+
+- 新增规则模板请参考 [RULE_TEMPLATE.md](./RULE_TEMPLATE.md)
+- 完整开发指南请参考 [RULE_DEVELOPMENT_GUIDE.md](./RULE_DEVELOPMENT_GUIDE.md)

package/references/RULE_TEMPLATE.md

@@ -0,0 +1,192 @@
+---
+rule_id: "{RULE_ID}"
+name: "{RULE_NAME}"
+category: "{CATEGORY}"
+severity: "{SEVERITY}"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# {RULE_NAME}
+
+## 问题描述
+
+{一句话描述该规则检测的稳定性问题及其危害。}
+
+{可选：补充详细背景说明，如OpenHarmony特定要求、实际项目中的常见错误模式等}
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：{具体问题描述}
+{问题代码示例}
+
+// 场景2：{具体问题描述}
+{问题代码示例}
+
+// 场景3：{具体问题描述}
+{问题代码示例}
+
+// 场景4：{具体问题描述}
+{问题代码示例}
+
+// 场景5：{具体问题描述}
+{问题代码示例}
+
+// 建议：提供5-10个典型错误场景，覆盖常见变体和实际代码模式
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：{修复方法说明}
+{修复后的代码}
+
+// 修复场景2：{修复方法说明}
+{修复后的代码}
+
+// 修复场景3：{修复方法说明}
+{修复后的代码}
+
+// 修复场景4：{修复方法说明}
+{修复后的代码}
+
+// 修复场景5：{修复方法说明}
+{修复后的代码}
+
+// 建议：提供5-10个修复方案，包括最佳实践、RAII模式、实际代码中的标准写法
+```
+
+## 检测范围
+
+检查以下{API/函数/模式/场景}：
+
+1. {检测目标1}
+2. {检测目标2}
+3. {检测目标3}
+4. {检测目标4}
+5. {检测目标5}
+
+## 检测要点
+
+1. {检测步骤1：如何识别目标}
+2. {检测步骤2：如何检查问题}
+3. {检测步骤3：如何判断风险}
+4. {检测步骤4：如何排除误报}
+5. {检测步骤5：特殊情况处理}
+
+### {可选：扩展说明章节}
+
+{根据规则特点添加以下可选章节：}
+
+#### 最佳实践说明
+
+{说明该类问题的最佳实践模式，如：}
+- **推荐方式1**：{说明}
+  - 适用场景：{场景}
+  - 示例：`{代码片段}`
+  
+- **推荐方式2**：{说明}
+  - 适用场景：{场景}
+  - 示例：`{代码片段}`
+
+#### 实际代码参考
+
+{引用实际项目中的具体函数、常量、模式}
+- **实际常量值**：`MAX_NESTING_DEPTH = 800`, `RECORD_CMD_MAX_DEPTH = 800`
+- **实际函数名**：`RSCanvasDrawingRenderNodeDrawable::CreateGpuSurface`
+- **实际日志函数**：`ROSEN_LOGE()`, `RS_LOGE()`
+
+#### 特殊技术说明
+
+{针对复杂技术点提供详细说明}
+- **memory_order使用**：{详细说明不同memory_order的适用场景}
+- **thread_local最佳实践**：{说明何时使用thread_local}
+- **C++11/20特性**：{说明新标准特性如何改进代码}
+- **POD vs 非POD类型**：{说明类型差异和初始化要求}
+
+#### 分类处理策略
+
+{针对不同场景提供不同的处理方式}
+- **场景A**：{处理方式1}
+- **场景B**：{处理方式2}
+- **场景C**：{处理方式3}
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: {稳定性风险来源描述，具体到代码元素}
+- **RISK_TYPE**: {具体的稳定性风险类型，如空指针解引用、UAF、数据竞争等}
+- **RISK_PATH**: {风险传播的完整路径，从来源到影响点}
+- **IMPACT_POINT**: {最终影响系统稳定性的点，如崩溃、资源耗尽等}
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: {触发条件，具体场景描述}
+- **Propagation**: {风险传播方式，具体机制}
+- **Consequence**: {稳定性后果，具体表现}
+- **Mitigation**: {缓解建议，具体修复方案}
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT标记 | 有 // NOPROTECT 注释 | 不报 |
+| 已有安全防护 | {具体识别方法} | 不报 |
+| 使用最佳实践 | {具体识别方法} | 不报 |
+| 第三方库 | 位于 third_party 目录 | 白名单排除 |
+| 测试代码 | 位于 test 目录或 _test.cpp 文件 | 自动跳过 |
+| {其他场景} | {识别方法} | {处理方式} |
+
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_{RULE_ID}_trigger.cpp
+void trigger_bad_1()
+{
+    // {触发场景1的代码}
+}
+
+void trigger_bad_2()
+{
+    // {触发场景2的代码}
+}
+
+void trigger_bad_3()
+{
+    // {触发场景3的代码}
+}
+
+// 建议：提供5-10个触发用例，覆盖典型错误模式和边界情况
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_{RULE_ID}_safe.cpp
+void safe_good_1()
+{
+    // {安全写法1的代码}
+}
+
+void safe_good_2()
+{
+    // {安全写法2的代码}
+}
+
+void safe_good_3()
+{
+    // {安全写法3的代码}
+}
+
+void noprotect_case()
+{
+    // NOPROTECT: {特殊场景说明}
+    // {有NOPROTECT标记的代码}
+}
+
+// 建议：提供5-10个安全用例，覆盖正确做法和误报排除场景
+```

package/references/ResourceManagement/StabilityCodeReview_ResourceManagement_001.md

@@ -0,0 +1,334 @@
+---
+rule_id: "StabilityCodeReview_ResourceManagement_001"
+name: "反序列化内存泄漏"
+category: "资源管理"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 反序列化内存泄漏
+
+## 问题描述
+
+在反序列化过程中申请的内存在异常分支未及时释放，造成内存泄漏。反序列化代码中常见的模式是先申请内存，然后读取数据填充，如果读取过程中发生错误，需要正确释放已申请的内存，否则会导致内存泄漏。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：反序列化失败后内存未释放
+Data* DeserializeData(Parcel& parcel)
+{
+    Data* data = new Data();  // 申请内存
+    int count = parcel.ReadInt32();
+    if (count < 0 || count > MAX_COUNT) {
+        LOGE("Invalid count: %d", count);
+        return nullptr;  // 错误：返回nullptr，data内存泄漏
+    }
+    data->count = count;
+    data->name = parcel.ReadString();
+    return data;
+}
+
+// 场景2：嵌套反序列化内存泄漏
+TreeNode* DeserializeTree(Parcel& parcel)
+{
+    TreeNode* node = new TreeNode();  // 申请内存
+    node->id = parcel.ReadInt32();
+    int childCount = parcel.ReadInt32();
+    
+    if (childCount < 0) {
+        LOGE("Invalid childCount");
+        return nullptr;  // 错误：node内存泄漏
+    }
+    
+    for (int i = 0; i < childCount; i++) {
+        TreeNode* child = DeserializeTree(parcel);
+        if (child == nullptr) {
+            // 错误：child反序列化失败，但node已创建
+            // 未清理其他已添加的children
+            return nullptr;  // node和已添加的children全部泄漏
+        }
+        node->children.push_back(child);
+    }
+    return node;
+}
+
+// 场景3：数组反序列化部分失败泄漏
+int* DeserializeArray(Parcel& parcel, int& size)
+{
+    size = parcel.ReadInt32();
+    if (size < 0 || size > MAX_SIZE) {
+        return nullptr;  // 此处正确，内存未申请
+    }
+    
+    int* arr = new int[size];  // 申请内存
+    for (int i = 0; i < size; i++) {
+        int value = parcel.ReadInt32();
+        if (value < 0) {  // 业务校验失败
+            LOGE("Invalid value at index %d", i);
+            return nullptr;  // 错误：arr内存泄漏
+        }
+        arr[i] = value;
+    }
+    return arr;
+}
+
+// 场景4：对象成员反序列化失败泄漏
+class Config {
+public:
+    char* buffer_;
+    int bufferSize_;
+    
+    bool Deserialize(Parcel& parcel) {
+        bufferSize_ = parcel.ReadInt32();
+        if (bufferSize_ <= 0 || bufferSize_ > MAX_BUFFER) {
+            return false;  // 正确：buffer_未申请
+        }
+        
+        buffer_ = new char[bufferSize_];  // 申请内存
+        if (!parcel.ReadBuffer(buffer_, bufferSize_)) {
+            LOGE("ReadBuffer failed");
+            return false;  // 错误：buffer_内存泄漏
+        }
+        return true;
+    }
+};
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：使用智能指针自动管理
+Data* DeserializeData(Parcel& parcel)
+{
+    std::unique_ptr<Data> data(new Data());  // 使用unique_ptr管理
+    int count = parcel.ReadInt32();
+    if (count < 0 || count > MAX_COUNT) {
+        LOGE("Invalid count: %d", count);
+        return nullptr;  // unique_ptr自动释放
+    }
+    data->count = count;
+    data->name = parcel.ReadString();
+    return data.release();  // 成功时释放所有权
+}
+
+// 修复场景2：嵌套反序列化安全清理
+TreeNode* DeserializeTree(Parcel& parcel)
+{
+    std::unique_ptr<TreeNode> node(new TreeNode());
+    node->id = parcel.ReadInt32();
+    int childCount = parcel.ReadInt32();
+    
+    if (childCount < 0) {
+        LOGE("Invalid childCount");
+        return nullptr;  // unique_ptr自动释放node
+    }
+    
+    for (int i = 0; i < childCount; i++) {
+        TreeNode* child = DeserializeTree(parcel);
+        if (child == nullptr) {
+            // unique_ptr会自动清理node和已添加的children
+            return nullptr;
+        }
+        node->children.push_back(child);
+    }
+    return node.release();
+}
+
+// 修复场景3：数组反序列化安全清理
+int* DeserializeArray(Parcel& parcel, int& size)
+{
+    size = parcel.ReadInt32();
+    if (size < 0 || size > MAX_SIZE) {
+        return nullptr;
+    }
+    
+    std::unique_ptr<int[]> arr(new int[size]);
+    for (int i = 0; i < size; i++) {
+        int value = parcel.ReadInt32();
+        if (value < 0) {
+            LOGE("Invalid value at index %d", i);
+            return nullptr;  // unique_ptr自动释放
+        }
+        arr[i] = value;
+    }
+    return arr.release();
+}
+
+// 修复场景4：对象成员使用智能指针
+class Config {
+public:
+    std::unique_ptr<char[]> buffer_;
+    int bufferSize_;
+    
+    bool Deserialize(Parcel& parcel) {
+        bufferSize_ = parcel.ReadInt32();
+        if (bufferSize_ <= 0 || bufferSize_ > MAX_BUFFER) {
+            return false;
+        }
+        
+        buffer_.reset(new char[bufferSize_]);  // unique_ptr管理
+        if (!parcel.ReadBuffer(buffer_.get(), bufferSize_)) {
+            LOGE("ReadBuffer failed");
+            buffer_.reset();  // 或自动清理
+            return false;
+        }
+        return true;
+    }
+};
+
+// 修复场景5：手动释放内存
+Data* DeserializeDataManual(Parcel& parcel)
+{
+    Data* data = new Data();
+    int count = parcel.ReadInt32();
+    if (count < 0 || count > MAX_COUNT) {
+        LOGE("Invalid count: %d", count);
+        delete data;  // 手动释放
+        return nullptr;
+    }
+    data->count = count;
+    data->name = parcel.ReadString();
+    return data;
+}
+
+// 修复场景6：使用goto统一清理（C风格）
+int* DeserializeArrayGoto(Parcel& parcel, int& size)
+{
+    int* arr = nullptr;
+    
+    size = parcel.ReadInt32();
+    if (size < 0 || size > MAX_SIZE) {
+        goto error;
+    }
+    
+    arr = new int[size];
+    for (int i = 0; i < size; i++) {
+        int value = parcel.ReadInt32();
+        if (value < 0) {
+            LOGE("Invalid value");
+            goto error;
+        }
+        arr[i] = value;
+    }
+    return arr;
+    
+error:
+    if (arr) {
+        delete[] arr;
+    }
+    size = 0;
+    return nullptr;
+}
+```
+
+## 检测范围
+
+检查以下模式：
+
+- `new/delete` 在反序列化函数中的使用
+- `malloc/free` 在反序列化函数中的使用
+- 异常分支（`return nullptr`, `return false`, `return -1`等）前未释放内存
+- 反序列化函数中多个内存申请点的清理
+
+## 检测要点
+
+1. 识别反序列化函数（包含`Parcel`, `Deserialize`, `Unmarshal`, `Read`等关键字）
+2. 检测内存申请操作（`new`, `malloc`, `calloc`）
+3. 检测异常返回分支
+4. 检查异常分支前是否有对应的释放操作
+5. 排除使用智能指针的情况
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**：反序列化函数中申请的内存
+- **RISK_TYPE**：内存泄漏
+- **RISK_PATH**：申请内存 -> 异常分支 -> 未释放返回 -> 内存泄漏
+- **IMPACT_POINT**：内存资源耗尽、程序稳定性下降
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**：反序列化过程中遇到异常数据或读取失败
+- **Propagation**：异常分支返回时未释放已申请内存
+- **Consequence**：内存泄漏累积、系统内存耗尽、性能下降
+- **Mitigation**：使用智能指针自动管理或手动释放内存
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| 使用智能指针 | unique_ptr/shared_ptr | 不报 |
+| 有delete释放 | 异常分支前有delete/free | 不报 |
+| 使用RAII类 | 封装了清理的类对象 | 不报 |
+| NOPROTECT标记 | 有 // NOPROTECT 注释 | 不报 |
+| 第三方库 | 位于 third_party 目录 | 白名单排除 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_ResourceManagement_001_trigger.cpp
+Data* trigger_bad_1(Parcel& parcel)
+{
+    Data* data = new Data();  // 应该报：new后异常返回未释放
+    int count = parcel.ReadInt32();
+    if (count < 0) {
+        return nullptr;  // 内存泄漏
+    }
+    data->count = count;
+    return data;
+}
+
+int* trigger_bad_2(Parcel& parcel)
+{
+    int* arr = (int*)malloc(100 * sizeof(int));  // 应该报：malloc后异常返回未释放
+    int value = parcel.ReadInt32();
+    if (value < 0) {
+        return nullptr;  // 内存泄漏
+    }
+    arr[0] = value;
+    return arr;
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_ResourceManagement_001_safe.cpp
+Data* safe_good_1(Parcel& parcel)
+{
+    std::unique_ptr<Data> data(new Data());  // 安全：使用智能指针
+    int count = parcel.ReadInt32();
+    if (count < 0) {
+        return nullptr;  // unique_ptr自动释放
+    }
+    data->count = count;
+    return data.release();
+}
+
+Data* safe_good_2(Parcel& parcel)
+{
+    Data* data = new Data();
+    int count = parcel.ReadInt32();
+    if (count < 0) {
+        delete data;  // 安全：手动释放
+        return nullptr;
+    }
+    data->count = count;
+    return data;
+}
+
+// NOPROTECT: 特殊场景
+// NOPROTECT: 测试代码
+Data* noprotect_case(Parcel& parcel)
+{
+    Data* data = new Data();
+    if (parcel.ReadInt32() < 0) {
+        return nullptr;
+    }
+    return data;
+}
+```