@ohos-graphics/stability-code-review 0.1.0

package/references/MemoryStability/StabilityCodeReview_MemoryStability_005.md

@@ -0,0 +1,364 @@
+---
+rule_id: "StabilityCodeReview_MemoryStability_005"
+name: "double-free问题"
+category: "内存稳定性"
+severity: "CRITICAL"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# double-free问题
+
+## 问题描述
+
+同一指针在多条代码路径被多次释放，或释放后未置空导致后续再次释放，引发内存管理混乱。double-free会导致堆内存结构损坏、程序崩溃、潜在的安全漏洞，甚至可能被攻击者利用执行任意代码。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：多条路径重复释放同一内存
+void ProcessData(Data* data)
+{
+    if (data == nullptr) {
+        return;
+    }
+    
+    if (!ValidateData(data)) {
+        free(data);  // 第一次释放
+        return;
+    }
+    
+    if (!ProcessDataInternal(data)) {
+        free(data);  // 第二次释放（如果ValidateData失败路径已释放）
+        return;
+    }
+    
+    free(data);  // 第三次释放（可能重复）
+}
+
+// 场景2：释放后未置空导致后续释放
+void HandleBuffer()
+{
+    char* buffer = (char*)malloc(1024);
+    if (buffer == nullptr) {
+        return;
+    }
+    
+    ProcessBuffer(buffer);
+    free(buffer);  // 释放
+    
+    if (errorCondition) {
+        free(buffer);  // 错误：buffer已释放，再次释放导致double-free
+    }
+}
+
+// 场景3：条件分支重复释放
+int ManageResource()
+{
+    Resource* res = new Resource();
+    
+    if (condition1) {
+        delete res;  // 第一条路径释放
+        return -1;
+    }
+    
+    if (condition2) {
+        delete res;  // 第二条路径释放（如果condition1为true，已释放）
+        return -2;
+    }
+    
+    delete res;  // 正常路径释放
+    return 0;
+}
+
+// 场景4：循环中释放后继续使用指针
+void ProcessItems(Item* items, int count)
+{
+    for (int i = 0; i < count; i++) {
+        free(items[i].data);
+        items[i].data = nullptr;  // 正确：置空
+        
+        if (i > 0 && items[i].data == items[i-1].data) {
+            free(items[i].data);  // 错误：可能释放同一块内存两次
+        }
+    }
+}
+
+// 场景5：智能指针get()后手动删除
+void SmartPtrMisuse()
+{
+    std::unique_ptr<Data> ptr = std::make_unique<Data>();
+    Data* raw = ptr.get();
+    
+    delete raw;  // 错误：unique_ptr会在析构时再次释放
+    
+    // ptr析构时再次delete raw，导致double-free
+}
+
+// 场景6：成员指针多处释放
+class Container {
+public:
+    ~Container() {
+        if (data_) {
+            delete data_;  // 析构时释放
+        }
+    }
+    
+    void Clear() {
+        if (data_) {
+            delete data_;  // Clear时释放
+            data_ = nullptr;  // 正确：置空避免析构时重复释放
+        }
+    }
+    
+private:
+    Data* data_;
+};
+
+// 错误使用：先Clear()后析构会double-free（如果未置空）
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：统一释放点，避免多路径重复释放
+void ProcessData(Data* data)
+{
+    if (data == nullptr) {
+        return;
+    }
+    
+    bool success = false;
+    
+    if (ValidateData(data)) {
+        success = ProcessDataInternal(data);
+    }
+    
+    free(data);  // 正确：统一释放点，只释放一次
+}
+
+// 修复场景2：释放后立即置空
+void HandleBuffer()
+{
+    char* buffer = (char*)malloc(1024);
+    if (buffer == nullptr) {
+        return;
+    }
+    
+    ProcessBuffer(buffer);
+    free(buffer);
+    buffer = nullptr;  // 正确：置空，后续释放安全
+    
+    if (errorCondition) {
+        free(buffer);  // 安全：buffer为nullptr，free(nullptr)安全
+    }
+}
+
+// 修复场景3：使用智能指针避免手动管理
+int ManageResource()
+{
+    std::unique_ptr<Resource> res = std::make_unique<Resource>();
+    
+    if (condition1) {
+        return -1;  // 安全：智能指针自动释放一次
+    }
+    
+    if (condition2) {
+        return -2;  // 安全：智能指针自动释放一次
+    }
+    
+    return 0;  // 安全：智能指针自动释放一次
+}
+
+// 修复场景4：正确管理循环中的释放
+void ProcessItems(Item* items, int count)
+{
+    for (int i = 0; i < count; i++) {
+        if (items[i].data != nullptr) {
+            free(items[i].data);
+            items[i].data = nullptr;  // 正确：立即置空
+        }
+    }
+    
+    // 避免重复释放相同指针
+}
+
+// 修复场景5：不要混用智能指针和手动delete
+void SmartPtrCorrect()
+{
+    std::unique_ptr<Data> ptr = std::make_unique<Data>();
+    Data* raw = ptr.get();
+    
+    // 使用raw指针，但不手动delete
+    raw->Process();  // 正确：只使用，不手动释放
+    
+    // unique_ptr析构时自动释放
+}
+
+// 修复场景6：成员指针统一管理，确保置空
+class Container {
+public:
+    ~Container() {
+        Clear();  // 正确：调用Clear统一管理
+    }
+    
+    void Clear() {
+        if (data_) {
+            delete data_;
+            data_ = nullptr;  // 正确：置空，析构时不再释放
+        }
+    }
+    
+private:
+    Data* data_ = nullptr;  // 初始化为nullptr
+};
+```
+
+## 检测范围
+
+检查以下模式：
+
+1. 同一指针变量在多处调用 `free()` / `delete` / `delete[]`
+2. 释放后未置空（`nullptr`），后续可能再次释放
+3. 智能指针 `get()` 后手动 `delete`
+4. 多个条件分支中重复释放同一指针
+5. 循环中重复释放同一指针
+6. 类成员指针在多处释放且未置空
+
+## 检测要点
+
+1. 识别指针变量及其释放操作（free、delete、delete[]）
+2. 统计同一指针的释放操作次数
+3. 检查释放后是否有置空操作（`= nullptr`）
+4. 分析控制流，判断是否存在多条路径到达释放点
+5. 排除智能指针、RAII类等自动管理场景
+6. 排除NOPROTECT标记
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**：手动管理的指针变量
+- **RISK_TYPE**：double-free（重复释放）
+- **RISK_PATH**：同一指针多次释放 → 堆内存结构损坏 → 未定义行为 → 程序崩溃或安全漏洞
+- **IMPACT_POINT**：堆管理器损坏，程序崩溃，潜在任意代码执行
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**：多条代码路径都执行释放操作，或释放后未置空再次释放
+- **Propagation**：堆内存结构损坏，后续内存操作异常
+- **Consequence**：程序崩溃、数据损坏、潜在安全漏洞（攻击者可利用堆损坏执行代码）
+- **Mitigation**：使用智能指针、释放后置空、统一释放点
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| 使用智能指针 | unique_ptr/shared_ptr | 不报 |
+| 释放后置空 | ptr = nullptr / ptr = NULL | 不报 |
+| 不同指针变量 | 不同变量名 | 不报 |
+| 成员指针正确管理 | Clear()置空后析构检查nullptr | 不报 |
+| NOPROTECT标记 | // NOPROTECT 注释 | 不报 |
+| 测试代码 | 文件名包含 _test.cpp | 白名单排除 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_MemoryStability_005_trigger.cpp
+#include <cstdlib>
+
+void trigger_bad_1(Data* data)
+{
+    if (!ValidateData(data)) {
+        free(data);  // 应该报：第一条路径释放
+        return;
+    }
+    
+    free(data);  // 应该报：第二条路径可能重复释放
+}
+
+void trigger_bad_2()
+{
+    char* buffer = (char*)malloc(1024);
+    free(buffer);
+    free(buffer);  // 应该报：double-free，未置空
+}
+
+void trigger_bad_3()
+{
+    std::unique_ptr<Data> ptr = std::make_unique<Data>();
+    Data* raw = ptr.get();
+    delete raw;  // 应该报：智能指针get()后手动delete
+}
+
+void trigger_bad_4()
+{
+    int* arr = new int[100];
+    if (condition1) {
+        delete[] arr;  // 应该报：第一条路径释放
+        return;
+    }
+    
+    if (condition2) {
+        delete[] arr;  // 应该报：第二条路径释放
+        return;
+    }
+    
+    delete[] arr;  // 应该报：第三条路径释放
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_MemoryStability_005_safe.cpp
+#include <cstdlib>
+#include <memory>
+
+void safe_good_1(Data* data)
+{
+    free(data);  // 只释放一次
+}
+
+void safe_good_2()
+{
+    char* buffer = (char*)malloc(1024);
+    free(buffer);
+    buffer = nullptr;  // 安全：置空后不再释放
+}
+
+void safe_good_3()
+{
+    std::unique_ptr<Data> ptr = std::make_unique<Data>();
+    ptr->Process();  // 安全：使用智能指针，不手动delete
+}
+
+void safe_good_4()
+{
+    int* arr = new int[100];
+    int result = 0;
+    
+    do {
+        if (condition1) {
+            result = -1;
+            break;  // 安全：跳转到统一释放点
+        }
+        
+        if (condition2) {
+            result = -2;
+            break;  // 安全：跳转到统一释放点
+        }
+    } while (0);
+    
+    delete[] arr;  // 只释放一次
+}
+
+// NOPROTECT: 特殊场景
+void noprotect_case()
+{
+    int* data = new int[100];
+    delete[] data;
+    delete[] data;  // NOPROTECT标记，不报
+}
+```

package/references/MemoryStability/StabilityCodeReview_MemoryStability_006.md

@@ -0,0 +1,359 @@
+---
+rule_id: "StabilityCodeReview_MemoryStability_006"
+name: "use-after-free问题"
+category: "内存稳定性"
+severity: "CRITICAL"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# use-after-free问题
+
+## 问题描述
+
+指针被释放后，后续代码仍对其进行解引用、成员访问或传递给其他函数，导致访问已释放的内存，可能引发崩溃。use-after-free是严重的内存安全问题，可能导致程序崩溃、数据损坏，甚至被攻击者利用执行任意代码。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：释放后继续使用指针
+void ProcessData(Data* data)
+{
+    if (data == nullptr) {
+        return;
+    }
+    
+    free(data);
+    data->value = 100;  // 错误：释放后访问已释放的内存
+}
+
+// 场景2：释放后传递给其他函数
+void HandleBuffer()
+{
+    char* buffer = (char*)malloc(1024);
+    if (buffer == nullptr) {
+        return;
+    }
+    
+    ProcessBuffer(buffer);
+    free(buffer);
+    
+    ValidateBuffer(buffer);  // 错误：传递已释放的指针给其他函数
+}
+
+// 场景3：释放后读取指针值
+int GetDataValue()
+{
+    int* value = new int(100);
+    int result = *value;
+    
+    delete value;
+    return *value;  // 错误：释放后再次读取
+}
+
+// 场景4：释放后访问成员
+void UpdateNode(Node* node)
+{
+    if (node == nullptr) {
+        return;
+    }
+    
+    Node* next = node->next;
+    free(node);
+    
+    node->value = 100;  // 错误：释放后访问成员
+    node->next = nullptr;  // 错误：释放后访问成员
+}
+
+// 场景5：释放后调用方法
+void UseObject()
+{
+    Object* obj = new Object();
+    obj->Initialize();
+    
+    delete obj;
+    obj->Process();  // 错误：释放后调用方法
+}
+
+// 场景6：数组释放后访问元素
+void ProcessArray()
+{
+    int* arr = new int[100];
+    for (int i = 0; i < 100; i++) {
+        arr[i] = i;
+    }
+    
+    delete[] arr;
+    int sum = 0;
+    for (int i = 0; i < 100; i++) {
+        sum += arr[i];  // 错误：释放后访问数组元素
+    }
+}
+
+// 场景7：链式释放后使用
+void ProcessList(Node* head)
+{
+    Node* current = head;
+    while (current != nullptr) {
+        Node* next = current->next;
+        free(current);
+        current->value = 100;  // 错误：释放后使用
+        current = next;  // 正确：使用保存的next指针
+    }
+}
+
+// 场景8：局部变量释放后返回引用
+int& GetLocalValue()
+{
+    int* value = new int(100);
+    int result = *value;
+    delete value;
+    return *value;  // 错误：返回已释放内存的引用
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：释放前完成所有操作，或释放后置空
+void ProcessData(Data* data)
+{
+    if (data == nullptr) {
+        return;
+    }
+    
+    data->value = 100;  // 正确：释放前完成操作
+    free(data);
+    data = nullptr;  // 正确：置空避免后续误用
+}
+
+// 修复场景2：释放后置空，避免传递
+void HandleBuffer()
+{
+    char* buffer = (char*)malloc(1024);
+    if (buffer == nullptr) {
+        return;
+    }
+    
+    ProcessBuffer(buffer);
+    ValidateBuffer(buffer);  // 正确：释放前完成验证
+    free(buffer);
+    buffer = nullptr;  // 正确：置空
+}
+
+// 修复场景3：保存值后释放，不要再次访问
+int GetDataValue()
+{
+    int* value = new int(100);
+    int result = *value;  // 正确：先保存值
+    
+    delete value;
+    return result;  // 正确：返回保存的值，不访问已释放内存
+}
+
+// 修复场景4：释放前保存需要的值，或释放后置空
+void UpdateNode(Node* node)
+{
+    if (node == nullptr) {
+        return;
+    }
+    
+    Node* next = node->next;  // 正确：释放前保存next
+    int value = node->value;  // 正确：释放前保存value
+    
+    free(node);
+    node = nullptr;  // 正确：置空
+    
+    // 使用保存的值
+    if (next != nullptr) {
+        next->value = 100;
+    }
+}
+
+// 修复场景5：使用智能指针自动管理
+void UseObject()
+{
+    std::unique_ptr<Object> obj = std::make_unique<Object>();
+    obj->Initialize();
+    obj->Process();  // 正确：智能指针自动管理生命周期
+}
+
+// 修复场景6：使用容器代替手动数组管理
+void ProcessArray()
+{
+    std::vector<int> arr(100);
+    for (int i = 0; i < 100; i++) {
+        arr[i] = i;
+    }
+    
+    int sum = 0;
+    for (int i = 0; i < 100; i++) {
+        sum += arr[i];  // 正确：vector自动管理内存
+    }
+}
+
+// 修复场景7：正确遍历链表释放
+void ProcessList(Node* head)
+{
+    Node* current = head;
+    while (current != nullptr) {
+        Node* next = current->next;  // 正确：释放前保存next
+        ProcessNode(current);  // 正确：释放前处理
+        
+        free(current);
+        current = next;  // 正确：使用保存的next指针
+    }
+}
+
+// 修复场景8：不要返回局部内存的引用
+int GetLocalValue()
+{
+    int value = 100;  // 正确：使用栈变量
+    return value;  // 正确：返回值，不是引用
+}
+```
+
+## 检测范围
+
+检查以下模式：
+
+1. `free()` / `delete` / `delete[]` 后，指针被解引用（`*ptr`、`ptr->`）
+2. 释放后，指针被传递给其他函数
+3. 释放后，指针被作为返回值或赋值给其他变量
+4. 释放后，数组指针被访问元素（`ptr[index]`）
+5. 释放后，对象指针调用成员方法
+6. 链式释放后使用已释放的节点
+7. 返回已释放内存的引用
+
+## 检测要点
+
+1. 识别释放操作（free、delete、delete[]）
+2. 跟踪指针变量，检测释放后的使用
+3. 检查释放后是否存在解引用、成员访问、函数调用等操作
+4. 检查释放后是否有置空操作（`= nullptr`）
+5. 分析控制流，判断释放后是否还有使用路径
+6. 排除智能指针、RAII类等自动管理场景
+7. 排除NOPROTECT标记
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**：已释放的指针变量
+- **RISK_TYPE**：use-after-free（访问已释放内存）
+- **RISK_PATH**：指针释放 → 内存回收 → 继续访问 → 未定义行为 → 崩溃或安全漏洞
+- **IMPACT_POINT**：访问非法内存，程序崩溃，潜在任意代码执行
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**：释放后继续解引用或使用指针
+- **Propagation**：访问已回收的堆内存，可能被其他分配覆盖
+- **Consequence**：数据损坏、程序崩溃（SIGSEGV）、潜在安全漏洞（攻击者可利用UAF执行代码）
+- **Mitigation**：释放后置空、使用智能指针、释放前完成所有操作
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| 释放后置空 | ptr = nullptr / ptr = NULL | 不报（置空后使用是空指针问题） |
+| 使用智能指针 | unique_ptr/shared_ptr | 不报 |
+| 释放前保存值 | 使用临时变量保存 | 不报（如果不再访问原指针） |
+| 不同指针变量 | 不同变量名（如current和next） | 不报 |
+| NOPROTECT标记 | // NOPROTECT 注释 | 不报 |
+| 测试代码 | 文件名包含 _test.cpp | 白名单排除 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_MemoryStability_006_trigger.cpp
+#include <cstdlib>
+
+void trigger_bad_1(Data* data)
+{
+    free(data);
+    data->value = 100;  // 应该报：释放后访问成员
+}
+
+void trigger_bad_2()
+{
+    char* buffer = (char*)malloc(1024);
+    free(buffer);
+    ValidateBuffer(buffer);  // 应该报：释放后传递给函数
+}
+
+void trigger_bad_3()
+{
+    int* value = new int(100);
+    delete value;
+    int result = *value;  // 应该报：释放后解引用
+}
+
+void trigger_bad_4()
+{
+    int* arr = new int[100];
+    delete[] arr;
+    arr[0] = 1;  // 应该报：释放后访问数组元素
+}
+
+void trigger_bad_5()
+{
+    Object* obj = new Object();
+    delete obj;
+    obj->Process();  // 应该报：释放后调用方法
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_MemoryStability_006_safe.cpp
+#include <cstdlib>
+#include <memory>
+#include <vector>
+
+void safe_good_1(Data* data)
+{
+    data->value = 100;  // 先使用
+    free(data);
+    data = nullptr;  // 置空
+}
+
+void safe_good_2()
+{
+    char* buffer = (char*)malloc(1024);
+    ProcessBuffer(buffer);  // 释放前使用
+    free(buffer);
+    buffer = nullptr;  // 置空
+}
+
+void safe_good_3()
+{
+    std::unique_ptr<Object> obj = std::make_unique<Object>();
+    obj->Process();  // 智能指针自动管理
+}
+
+void safe_good_4()
+{
+    std::vector<int> arr(100);
+    arr[0] = 1;  // vector自动管理内存
+}
+
+void safe_good_5(Node* head)
+{
+    Node* current = head;
+    while (current != nullptr) {
+        Node* next = current->next;  // 保存next
+        free(current);
+        current = next;  // 使用保存的next，不报
+    }
+}
+
+// NOPROTECT: 特殊场景
+void noprotect_case()
+{
+    int* value = new int(100);
+    delete value;
+    int result = *value;  // NOPROTECT标记，不报
+}
+```