@ohos-graphics/stability-code-review 0.1.0

package/references/Lifecycle/StabilityCodeReview_Lifecycle_002.md

@@ -0,0 +1,177 @@
+---
+rule_id: "StabilityCodeReview_Lifecycle_002"
+name: "获取临时变量指针"
+category: "生命周期"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 获取临时变量指针
+
+## 问题描述
+
+不建议获取临时变量的指针，容易出现未定义行为。临时变量（临时对象、右值）的生命周期通常很短，在表达式结束时即被销毁。获取临时变量的指针并在表达式结束后使用，会导致悬垂指针，访问已释放的内存，引发UAF（Use-After-Free）未定义行为。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：获取函数返回临时对象的指针
+std::string* ptr = &GetString();  // GetString()返回临时对象
+
+// 场景2：获取表达式临时对象的指针
+int* ptr = &(a + b);  // (a+b)是临时值
+
+// 场景3：保存临时容器的指针
+std::vector<int>* vec = &GetVector();  // GetVector()返回临时容器
+
+// 场景4：获取临时字符串的指针
+const char* str = GetTempString().c_str();  // GetTempString()返回临时string
+
+// 场景5：获取临时对象的成员指针
+int* ptr = &GetObject().value;  // GetObject()返回临时对象
+
+// 场景6：在条件表达式中使用临时变量指针
+int* ptr = condition ? &GetValue1() : &GetValue2();  // 两个都是临时对象
+
+// 场景7：获取强制类型转换临时对象的指针
+Derived* d = dynamic_cast<Derived*>(&GetBase());  // GetBase()返回临时对象
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：先存储到局部变量
+std::string temp = GetString();
+std::string* ptr = &temp;  // 正确：ptr指向有效的局部变量
+
+// 修复场景2：直接使用值
+int result = a + b;  // 使用值而非指针
+
+// 修复场景3：先存储容器
+std::vector<int> vec = GetVector();
+std::vector<int>* vecPtr = &vec;  // 正确
+
+// 修复场景4：先存储字符串
+std::string temp = GetTempString();
+const char* str = temp.c_str();  // 正确：temp生命周期足够
+
+// 修复场景5：先存储对象
+Object obj = GetObject();
+int* ptr = &obj.value;  // 正确
+
+// 修复场景6：存储结果后再使用
+int v1 = GetValue1();
+int v2 = GetValue2();
+int* ptr = condition ? &v1 : &v2;  // 正确
+
+// 修复场景7：正确处理类型转换
+Base base = GetBase();
+Derived* d = dynamic_cast<Derived*>(&base);  // 正确
+```
+
+## 检测范围
+
+检查以下模式：
+
+- `&函数调用()` - 获取函数返回临时对象的地址
+- `&(表达式)` - 获取表达式结果的地址
+- `&对象.成员` 结合临时对象
+- `临时对象.c_str()` - 获取临时字符串的C指针
+- `&强制转换表达式` - 获取临时转换结果的地址
+
+## 检测要点
+
+1. 识别取地址运算符 `&` 的使用
+2. 判断 `&` 后面是否为临时对象（函数调用返回值、表达式结果）
+3. 检测指针变量是否保存了临时对象的地址
+4. 排除取局部变量、成员变量地址的情况
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**：取地址运算符作用于临时对象
+- **RISK_TYPE**：悬垂指针（Dangling Pointer）/ UAF
+- **RISK_PATH**：获取临时对象指针 -> 表达式结束临时对象销毁 -> 指针指向已释放内存 -> 使用指针导致UAF
+- **IMPACT_POINT**：通过指针访问已销毁的临时对象内存
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**：表达式结束后使用保存的临时对象指针
+- **Propagation**：临时对象内存被回收或重用，指针变为悬垂指针
+- **Consequence**：未定义行为，可能表现为随机值、程序崩溃、数据损坏、安全漏洞
+- **Mitigation**：先将临时对象存储到具名变量，再获取其地址
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| 取局部变量地址 | `&variable` 其中variable是局部变量 | 不报 |
+| 取成员变量地址 | `&this->member` 或 `&member_` | 不报 |
+| 取参数地址 | `&param` | 不报 |
+| 取静态变量地址 | `&static_var` | 不报 |
+| 取数组元素地址 | `&arr[i]` | 不报 |
+| NOPROTECT标记 | 有 `// NOPROTECT` 注释 | 不报 |
+| 第三方库 | 位于 `third_party` 目录 | 白名单排除 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_Lifecycle_002_trigger.cpp
+std::string* trigger_bad_1() {
+    std::string* ptr = &GetString();  // 应该报：获取临时对象指针
+    return ptr;
+}
+
+int* trigger_bad_2(int a, int b) {
+    int* ptr = &(a + b);  // 应该报：获取表达式临时结果指针
+    return ptr;
+}
+
+const char* trigger_bad_3() {
+    const char* str = GetTempString().c_str();  // 应该报：获取临时字符串指针
+    return str;
+}
+
+std::vector<int>* trigger_bad_4() {
+    std::vector<int>* vec = &CreateVector();  // 应该报：获取临时容器指针
+    return vec;
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_Lifecycle_002_safe.cpp
+std::string* safe_good_1() {
+    std::string temp = GetString();
+    std::string* ptr = &temp;  // 安全：取局部变量地址
+    return ptr;
+}
+
+int* safe_good_2(int a, int b) {
+    int result = a + b;
+    int* ptr = &result;  // 安全：取局部变量地址
+    return ptr;
+}
+
+const char* safe_good_3() {
+    std::string temp = GetTempString();
+    const char* str = temp.c_str();  // 安全：temp生命周期足够
+    return str;
+}
+
+class MyClass {
+    int* safe_good_4(int index) {
+        return &arr_[index];  // 安全：取成员数组元素地址
+    }
+private:
+    int arr_[10];
+};
+
+int* safe_good_5(int& ref) {
+    return &ref;  // 安全：取引用参数地址
+}
+```

package/references/MemoryStability/StabilityCodeReview_MemoryStability_001.md

@@ -0,0 +1,332 @@
+---
+rule_id: "StabilityCodeReview_MemoryStability_001"
+name: "内存分配失败判空检查"
+category: "内存稳定性"
+severity: "CRITICAL"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 内存分配失败判空检查
+
+## 问题描述
+
+内存分配失败时的处理方式因分配函数类型而异，判空检查必须根据具体情况区分：
+
+**必须判空的场景**：
+- `malloc/calloc/realloc` 在失败时返回 `nullptr`，必须判空后使用，否则会导致空指针解引用崩溃
+- `new(std::nothrow)` 在失败时返回 `nullptr`，必须判空后使用，否则会导致空指针解引用崩溃
+
+**不需要判空的场景**：
+- 普通 `new` 在失败时会抛出 `std::bad_alloc` 异常，但由于 OpenHarmony 禁止使用异常，实际会直接终止程序，因此普通 new 后无需判空检查
+
+若对必须判空的内存分配未检查返回值就直接解引用，将导致空指针解引用，引发进程崩溃或拒绝服务。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：malloc未判空直接使用
+void ProcessData(int size)
+{
+    char* buffer = (char*)malloc(size);  // malloc
+    buffer[0] = '\0';  // 错误：buffer可能为nullptr，未判空直接访问
+    ProcessBuffer(buffer);
+    free(buffer);
+}
+
+// 场景2：calloc未判空
+void AllocateArray(int count)
+{
+    int* arr = (int*)calloc(count, sizeof(int));  // calloc
+    arr[0] = 100;  // 错误：arr可能为nullptr
+    free(arr);
+}
+
+// 场景3：realloc未判空
+void ResizeBuffer(char* oldBuffer, int newSize)
+{
+    char* newBuffer = (char*)realloc(oldBuffer, newSize);  // realloc
+    newBuffer[0] = '\0';  // 错误：realloc可能失败返回nullptr，oldBuffer已被释放
+}
+
+// 场景4：new(std::nothrow)未判空直接使用
+void ProcessData()
+{
+    Data* data = new(std::nothrow) Data();  // nothrow new
+    data->Initialize();  // 错误：未判空直接解引用，可能导致崩溃
+    data->Process();
+    delete data;
+}
+
+// 场景5：new(std::nothrow)数组未判空
+void AllocateBuffer()
+{
+    char* buffer = new(std::nothrow) char[1024];  // nothrow new
+    memcpy(buffer, source, 1024);  // 错误：buffer可能为nullptr
+    delete[] buffer;
+}
+
+// 场景6：链式malloc未判空
+void ChainAllocation()
+{
+    Node* head = (Node*)malloc(sizeof(Node));
+    head->next = (Node*)malloc(sizeof(Node));  // 错误：head可能为nullptr
+    head->next->value = 100;  // 错误：head->next可能为nullptr
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：malloc正确判空（实际代码中的标准模式）
+void ProcessData(int size)
+{
+    void* buffer = malloc(size);
+    if (buffer == nullptr) {  // ✅ 正确：malloc必须判空
+        ROSEN_LOGE("malloc failed, size:%{public}zu", size);  // 实际代码使用ROSEN_LOGE
+        return nullptr;
+    }
+    
+    errno_t err = memcpy_s(buffer, size, source, size);
+    if (err != EOK) {  // ✅ 正确：异常分支也要释放内存
+        free(buffer);
+        buffer = nullptr;
+        ROSEN_LOGE("memcpy_s failed, err:%{public}d", err);
+        return nullptr;
+    }
+    
+    // 正常使用
+    ProcessBuffer(buffer);
+    free(buffer);  // 使用后释放
+}
+
+// 修复场景1b：使用RAII（智能指针）替代手动管理（推荐）
+void ProcessDataRAII(int size)
+{
+    std::unique_ptr<char[]> buffer = std::make_unique<char[]>(size);  // ✅ 推荐：使用RAII
+    if (!buffer) {  // make_unique失败时返回nullptr（罕见）
+        ROSEN_LOGE("allocation failed");
+        return;
+    }
+    
+    ProcessBuffer(buffer.get());  // ✅ 安全：自动释放，无需手动free
+}
+
+// 修复场景2：calloc正确判空
+void AllocateArray(int count)
+{
+    int* arr = (int*)calloc(count, sizeof(int));
+    if (arr == nullptr) {
+        ROSEN_LOGE("calloc failed, count:%{public}d", count);
+        return;
+    }
+    arr[0] = 100;
+    free(arr);
+}
+
+// 修复场景3：realloc正确判空（注意realloc失败时原指针仍有效）
+void ResizeBuffer(char* oldBuffer, int newSize)
+{
+    char* newBuffer = (char*)realloc(oldBuffer, newSize);
+    if (newBuffer == nullptr) {  // 正确：realloc必须判空
+        LOGE("realloc failed");
+        free(oldBuffer);  // realloc失败时需要释放原指针
+        return;
+    }
+    newBuffer[0] = '\0';
+    // 使用newBuffer
+}
+
+// 修复场景4：nothrow new正确判空
+void ProcessData()
+{
+    Data* data = new(std::nothrow) Data();
+    if (data == nullptr) {  // 正确：nothrow new必须判空
+        LOGE("Failed to allocate Data");
+        return;
+    }
+    data->Initialize();
+    data->Process();
+    delete data;
+}
+
+// 修复场景5：nothrow new数组正确判空
+void AllocateBuffer()
+{
+    char* buffer = new(std::nothrow) char[1024];
+    if (buffer == nullptr) {  // 正确：判空后使用
+        LOGE("Failed to allocate buffer");
+        return;
+    }
+    memcpy(buffer, source, 1024);
+    delete[] buffer;
+}
+
+// 修复场景6：链式malloc逐一判空
+void ChainAllocation()
+{
+    Node* head = (Node*)malloc(sizeof(Node));
+    if (head == nullptr) {
+        LOGE("Failed to allocate head");
+        return;
+    }
+    
+    head->next = (Node*)malloc(sizeof(Node));
+    if (head->next == nullptr) {
+        LOGE("Failed to allocate next");
+        free(head);
+        return;
+    }
+    
+    head->next->value = 100;
+    free(head->next);
+    free(head);
+}
+
+// 修复场景7：使用智能指针替代手动管理
+void SmartPointerApproach()
+{
+    auto data = std::make_unique<Data>();  // 推荐：无需判空
+    data->Process();
+    
+    auto buffer = std::make_unique<char[]>(1024);  // 推荐：无需判空
+    memcpy(buffer.get(), source, 1024);
+}
+```
+
+## 检测范围
+
+检查以下模式：
+
+- `malloc()` 分配后的判空检查
+- `calloc()` 分配后的判空检查
+- `realloc()` 分配后的判空检查
+- `new(std::nothrow)` 分配后的判空检查
+- `new(std::nothrow)[]` 数组分配后的判空检查
+- 普通 `new` 后的冗余判空（作为提示）
+- 内存分配后紧接着的解引用操作
+
+## 检测要点
+
+1. 识别 `malloc/calloc/realloc` 或 `new(std::nothrow)` 内存分配
+2. 检查分配后的代码行是否有判空操作（if ptr == nullptr 等）
+3. 检查是否在判空前有解引用操作（ptr->、*ptr、ptr[0]等）
+4. 普通new后的判空作为冗余提示（非错误）
+5. 排除NOPROTECT标记和智能指针使用场景
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**：malloc/calloc/realloc/new(std::nothrow)分配的内存指针
+- **RISK_TYPE**：空指针解引用
+- **RISK_PATH**：内存分配返回nullptr -> 未判空直接使用 -> 空指针解引用崩溃
+- **IMPACT_POINT**：程序崩溃、服务中断、系统稳定性受损
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**：内存不足时malloc/calloc/realloc/new(std::nothrow)返回nullptr
+- **Propagation**：未判空直接解引用nullptr指针
+- **Consequence**：空指针解引用导致程序崩溃（SIGSEGV），拒绝服务
+- **Mitigation**：malloc/calloc/realloc/new(std::nothrow) 分配后必须判空，普通 new 不需要判空，或使用智能指针
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| 使用智能指针 | unique_ptr/shared_ptr/make_unique | 不报 |
+| 有判空操作 | if (ptr == nullptr) 或 if (!ptr) | 不报 |
+| NOPROTECT标记 | // NOPROTECT 注释 | 不报 |
+| 赋值给成员变量 | ptr = new(nothrow) 后单独函数判空 | 需上下文分析 |
+| 测试代码 | 文件名包含 _test.cpp | 白名单排除 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_MemoryStability_001_trigger.cpp
+void trigger_bad_1()
+{
+    char* buffer = (char*)malloc(1024);  // 应该报：malloc未判空
+    buffer[0] = '\0';  // 直接使用，buffer可能为nullptr
+}
+
+void trigger_bad_2()
+{
+    int* arr = (int*)calloc(100, sizeof(int));  // 应该报：calloc未判空
+    arr[0] = 100;  // 直接使用，arr可能为nullptr
+}
+
+void trigger_bad_3()
+{
+    Data* data = new(std::nothrow) Data();  // 应该报：nothrow new未判空
+    data->Process();  // 直接解引用，data可能为nullptr
+}
+
+void trigger_bad_4()
+{
+    int* arr = new(std::nothrow) int[100];  // 应该报：nothrow new数组未判空
+    arr[0] = 1;  // 直接使用，arr可能为nullptr
+}
+
+void trigger_bad_5()
+{
+    char* buf = new(nothrow) char[256];  // 应该报：简写nothrow未判空
+    *buf = '\0';  // 直接解引用
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_MemoryStability_001_safe.cpp
+void safe_good_1()
+{
+    char* buffer = (char*)malloc(1024);
+    if (buffer == nullptr) {  // 安全：malloc正确判空
+        return;
+    }
+    buffer[0] = '\0';
+    free(buffer);
+}
+
+void safe_good_2()
+{
+    int* arr = (int*)calloc(100, sizeof(int));
+    if (arr == nullptr) {  // 安全：calloc正确判空
+        return;
+    }
+    arr[0] = 100;
+    free(arr);
+}
+
+void safe_good_3()
+{
+    Data* data = new(std::nothrow) Data();
+    if (data == nullptr) {  // 安全：正确判空
+        return;
+    }
+    data->Process();
+    delete data;
+}
+
+void safe_good_4()
+{
+    auto data = std::make_unique<Data>();  // 安全：使用智能指针
+    data->Process();
+}
+
+void safe_good_5()
+{
+    Data* data = new Data();  // 安全：普通new，OpenHarmony禁止异常
+    data->Process();  // 普通new失败会终止程序，不需要判空
+    delete data;
+}
+
+// NOPROTECT: 特殊场景
+void noprotect_case()
+{
+    Data* data = new(std::nothrow) Data();
+    data->Process();  // NOPROTECT标记，不报
+}
+```