@ohos-graphics/stability-code-review 0.1.0

package/references/BoundaryCondition/StabilityCodeReview_BoundaryCondition_010.md

@@ -0,0 +1,472 @@
+---
+rule_id: "StabilityCodeReview_BoundaryCondition_010"
+name: "容器find返回迭代器需校验有效性"
+category: "边界条件"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 容器find返回迭代器需校验有效性
+
+## 问题描述
+
+容器find返回的迭代器在使用前需要先校验有效性，直接使用可能为end()的迭代器会导致未定义行为、程序崩溃或内存访问错误。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 错误示例1：map find后直接使用
+std::map<int, std::string> dataMap;
+
+std::string GetValue(int key)
+{
+    auto it = dataMap.find(key);
+    return it->second;  // 危险：it可能是end()
+}
+
+// 错误示例2：unordered_map直接访问
+std::unordered_map<std::string, int> cache;
+
+int GetCachedValue(const std::string& key)
+{
+    auto it = cache.find(key);
+    return it->second;  // 危险：未检查有效性
+}
+
+// 错误示例3：set find后直接访问
+std::set<int> validIds;
+
+bool IsValid(int id)
+{
+    auto it = validIds.find(id);
+    return *it == id;  // 危险：it可能是end()
+}
+
+// 错误示例4：vector find后访问
+std::vector<int> numbers;
+
+int GetFirstMatch(int value)
+{
+    auto it = std::find(numbers.begin(), numbers.end(), value);
+    return *it;  // 危险：it可能是end()
+}
+
+// 错误示例5：多重容器find
+std::multimap<int, std::string> multiMap;
+
+std::string GetFirstValue(int key)
+{
+    auto it = multiMap.find(key);
+    return it->second;  // 危险：未检查有效性
+}
+
+// 错误示例6：find后修改
+std::map<int, Data> dataStore;
+
+void UpdateData(int key, const Data& newData)
+{
+    auto it = dataStore.find(key);
+    it->second = newData;  // 危险：未检查有效性
+}
+
+// 错误示例7：find_if后使用
+std::vector<Item> items;
+
+Item* FindItemById(int id)
+{
+    auto it = std::find_if(items.begin(), items.end(), 
+        [id](const Item& item) { return item.id == id; });
+    return &(*it);  // 危险：it可能是end()
+}
+
+// 错误示例8：find后访问成员
+std::map<std::string, Config> configs;
+
+int GetConfigValue(const std::string& name)
+{
+    auto it = configs.find(name);
+    return it->second.value;  // 危险：未检查有效性
+}
+
+// 错误示例9：find后删除
+std::map<int, std::string> names;
+
+void RemoveName(int id)
+{
+    auto it = names.find(id);
+    names.erase(it);  // 危险：erase(end())未定义
+}
+
+// 错误示例10：链式find调用
+std::map<int, std::map<std::string, int>> nested;
+
+int GetNestedValue(int outerKey, const std::string& innerKey)
+{
+    auto outer = nested.find(outerKey);
+    auto inner = outer->second.find(innerKey);  // 危险：outer可能是end()
+    return inner->second;  // 危险：inner可能是end()
+}
+
+// 错误示例11：find后distance
+std::vector<int> vec;
+
+size_t GetIndex(int value)
+{
+    auto it = std::find(vec.begin(), vec.end(), value);
+    return std::distance(vec.begin(), it);  // 危险：it可能是end()，返回无效索引
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 正确示例1：map find后检查有效性
+std::map<int, std::string> dataMap;
+
+std::string GetValue(int key)
+{
+    auto it = dataMap.find(key);
+    if (it == dataMap.end()) {  // 正确：检查有效性
+        return "";  // 或返回默认值
+    }
+    return it->second;  // 安全：已验证有效
+}
+
+// 正确示例2：使用count()检查（更简洁）
+std::map<int, std::string> dataMap;
+
+std::string GetValue(int key)
+{
+    if (dataMap.count(key) > 0) {  // 正确：使用count检查
+        return dataMap[key];  // 安全：已确认存在
+    }
+    return "";
+}
+
+// 正确示例3：使用contains()检查（C++20，推荐）
+std::map<int, std::string> dataMap;
+
+std::string GetValue(int key)
+{
+    if (dataMap.contains(key)) {  // 正确：C++20 contains方法，语义更清晰
+        return dataMap[key];  // 安全：已确认存在
+    }
+    return "";
+}
+
+// 正确示例4：unordered_map find检查
+std::unordered_map<std::string, int> cache;
+
+int GetCachedValue(const std::string& key, int defaultValue = 0)
+{
+    auto it = cache.find(key);
+    if (it != cache.end()) {  // 正确：检查有效性
+        return it->second;
+    }
+    return defaultValue;  // 返回默认值
+}
+
+// 正确示例5：使用contains()替代find()（推荐）
+std::unordered_map<std::string, int> cache;
+
+bool HasCachedValue(const std::string& key)
+{
+    return cache.contains(key);  // 正确：C++20 contains，更简洁
+}
+
+int GetCachedValueSafe(const std::string& key)
+{
+    if (cache.contains(key)) {  // 正确：先检查存在性
+        return cache[key];  // 安全访问
+    }
+    return 0;  // 默认值
+}
+    return it->second;
+}
+
+// 正确示例2：unordered_map安全访问
+std::unordered_map<std::string, int> cache;
+
+int GetCachedValue(const std::string& key)
+{
+    auto it = cache.find(key);
+    if (it != cache.end()) {  // 正确：先检查
+        return it->second;
+    }
+    LOGE("Cache miss for key: %s", key.c_str());
+    return -1;
+}
+
+// 正确示例3：set find安全使用
+std::set<int> validIds;
+
+bool IsValid(int id)
+{
+    return validIds.find(id) != validIds.end();  // 正确：直接返回检查结果
+}
+
+// 正确示例4：vector find安全访问
+std::vector<int> numbers;
+
+int GetFirstMatch(int value, int defaultValue = -1)
+{
+    auto it = std::find(numbers.begin(), numbers.end(), value);
+    if (it == numbers.end()) {  // 正确：先检查
+        return defaultValue;
+    }
+    return *it;
+}
+
+// 正确示例5：多重容器find安全使用
+std::multimap<int, std::string> multiMap;
+
+std::string GetFirstValue(int key)
+{
+    auto it = multiMap.find(key);
+    if (it == multiMap.end()) {  // 正确：先检查
+        return "";
+    }
+    return it->second;
+}
+
+// 正确示例6：find后安全修改
+std::map<int, Data> dataStore;
+
+bool UpdateData(int key, const Data& newData)
+{
+    auto it = dataStore.find(key);
+    if (it == dataStore.end()) {  // 正确：先检查
+        LOGE("Key not found: %d", key);
+        return false;
+    }
+    it->second = newData;
+    return true;
+}
+
+// 正确示例7：find_if安全使用
+std::vector<Item> items;
+
+Item* FindItemById(int id)
+{
+    auto it = std::find_if(items.begin(), items.end(), 
+        [id](const Item& item) { return item.id == id; });
+    if (it == items.end()) {  // 正确：先检查
+        return nullptr;
+    }
+    return &(*it);
+}
+
+// 正确示例8：find后安全访问成员
+std::map<std::string, Config> configs;
+
+int GetConfigValue(const std::string& name, int defaultValue = 0)
+{
+    auto it = configs.find(name);
+    if (it == configs.end()) {  // 正确：先检查
+        return defaultValue;
+    }
+    return it->second.value;
+}
+
+// 正确示例9：find后安全删除
+std::map<int, std::string> names;
+
+bool RemoveName(int id)
+{
+    auto it = names.find(id);
+    if (it == names.end()) {  // 正确：先检查
+        LOGE("Name not found for id: %d", id);
+        return false;
+    }
+    names.erase(it);
+    return true;
+}
+
+// 正确示例10：链式find安全调用
+std::map<int, std::map<std::string, int>> nested;
+
+int GetNestedValue(int outerKey, const std::string& innerKey)
+{
+    auto outer = nested.find(outerKey);
+    if (outer == nested.end()) {  // 正确：先检查外层
+        LOGE("Outer key not found: %d", outerKey);
+        return -1;
+    }
+    auto inner = outer->second.find(innerKey);
+    if (inner == outer->second.end()) {  // 正确：再检查内层
+        LOGE("Inner key not found: %s", innerKey.c_str());
+        return -1;
+    }
+    return inner->second;
+}
+
+// 正确示例11：find后安全distance
+std::vector<int> vec;
+
+bool GetIndex(int value, size_t& index)
+{
+    auto it = std::find(vec.begin(), vec.end(), value);
+    if (it == vec.end()) {  // 正确：先检查
+        return false;
+    }
+    index = std::distance(vec.begin(), it);
+    return true;
+}
+
+// 正确示例12：使用辅助函数
+template<typename Container, typename Key>
+typename Container::mapped_type SafeFind(
+    Container& container, 
+    const Key& key,
+    typename Container::mapped_type defaultValue = {}
+) {
+    auto it = container.find(key);
+    if (it == container.end()) {
+        return defaultValue;
+    }
+    return it->second;
+}
+
+// 使用
+std::map<int, std::string> map;
+std::string value = SafeFind(map, key, "");
+
+// 正确示例13：使用contains检查（C++20）
+std::map<int, std::string> dataMap;
+
+bool HasKey(int key)
+{
+    return dataMap.contains(key);  // C++20: 直接检查是否存在
+}
+
+std::string GetValue(int key)
+{
+    if (dataMap.contains(key)) {  // 正确：先检查
+        return dataMap[key];
+    }
+    return "";
+}
+```
+
+## 检测范围
+
+检查以下模式：
+
+1. `container.find(key)` 后直接使用 `->`
+2. `std::find(begin, end, value)` 后直接使用 `*`
+3. `std::find_if(...)` 后直接访问
+4. find返回值用于erase但未检查
+5. 链式find调用未逐层检查
+
+## 检测要点
+
+1. 识别`find`, `find_if`函数调用
+2. 检查返回的迭代器是否与`end()`比较
+3. 检查在`if (it != end())`条件内使用
+4. 识别`->second`, `->first`, `*it`等访问操作
+5. 排除NOPROTECT标记的代码
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: find返回可能为end()的迭代器
+- **RISK_TYPE**: 使用无效迭代器
+- **RISK_PATH**: find -> 未检查 -> 直接访问 -> 未定义行为
+- **IMPACT_POINT**: 程序崩溃、内存访问错误
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: find后未校验迭代器有效性
+- **Propagation**: end()迭代器访问导致崩溃
+- **Consequence**: 程序崩溃、数据损坏、未定义行为
+- **Mitigation**: 使用前与end()比较，或使用contains/count
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 已有end检查 | 存在 != end() 或 == end() 判断 | 不报 |
+| 在条件内使用 | 在 if 条件返回true后使用 | 不报 |
+| 使用contains | 使用C++20 contains() | 不报 |
+| 第三方库 | 位于 third_party 目录 | 白名单排除 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_BoundaryCondition_010_trigger.cpp
+std::map<int, std::string> map;
+
+std::string trigger_bad_1(int key)
+{
+    auto it = map.find(key);
+    return it->second;  // 应该报：未检查end()
+}
+
+std::vector<int> vec;
+
+int trigger_bad_2(int value)
+{
+    auto it = std::find(vec.begin(), vec.end(), value);
+    return *it;  // 应该报：未检查end()
+}
+
+std::set<int> set;
+
+bool trigger_bad_3(int id)
+{
+    auto it = set.find(id);
+    return *it == id;  // 应该报：未检查end()
+}
+
+std::map<int, Data> dataMap;
+
+void trigger_bad_4(int key)
+{
+    auto it = dataMap.find(key);
+    it->second.value = 0;  // 应该报：未检查end()
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_BoundaryCondition_010_safe.cpp
+std::map<int, std::string> map;
+
+std::string safe_good_1(int key)
+{
+    auto it = map.find(key);
+    if (it == map.end()) {  // 安全：有检查
+        return "";
+    }
+    return it->second;
+}
+
+std::string safe_good_2(int key)
+{
+    auto it = map.find(key);
+    if (it != map.end()) {  // 安全：有检查
+        return it->second;
+    }
+    return "";
+}
+
+int safe_good_3(int key)
+{
+    if (map.count(key) > 0) {  // 安全：使用count检查
+        return map[key].length();
+    }
+    return 0;
+}
+
+// NOPROTECT: 特殊处理场景
+std::string noprotect_case(int key)
+{
+    auto it = map.find(key);
+    return it->second;
+}
+```

package/references/BoundaryCondition/StabilityCodeReview_BoundaryCondition_011.md

@@ -0,0 +1,204 @@
+---
+rule_id: "StabilityCodeReview_BoundaryCondition_011"
+name: "加减乘除运算应避免类型溢出或回绕"
+category: "边界条件"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 加减乘除运算应避免类型溢出或回绕
+
+## 问题描述
+
+整数运算时未检查溢出，可能导致数值回绕、逻辑错误或安全问题。尤其在内存分配大小计算、数组索引计算等关键场景，溢出可能导致内存分配不足或越界访问。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 错误示例1：乘法溢出导致内存分配不足
+void AllocateBuffer(int count, int itemSize)
+{
+    int totalSize = count * itemSize;  // 危险：可能溢出
+    char* buffer = new char[totalSize];
+    // ...
+}
+
+// 错误示例2：加法溢出
+void ProcessData(int offset, int length)
+{
+    int end = offset + length;  // 危险：可能溢出
+    for (int i = offset; i < end; i++) {
+        ProcessItem(i);
+    }
+}
+
+// 错误示例3：减法回绕（无符号）
+void CopyData(uint32_t start, uint32_t end)
+{
+    uint32_t size = end - start;  // 危险：若end < start，回绕到超大值
+    char* buffer = new char[size];
+    // ...
+}
+
+// 错误示例4：计算缓冲区大小
+int CalculateBufferSize(int width, int height, int bpp)
+{
+    return width * height * bpp;  // 危险：多次乘法可能溢出
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 正确示例1：乘法溢出检查
+void AllocateBuffer(int count, int itemSize)
+{
+    // 检查乘法溢出
+    if (itemSize > 0 && count > INT_MAX / itemSize) {
+        LOGE("Multiplication overflow: %d * %d", count, itemSize);
+        return;
+    }
+    int totalSize = count * itemSize;
+    if (totalSize <= 0) {
+        LOGE("Invalid size: %d", totalSize);
+        return;
+    }
+    char* buffer = new char[totalSize];
+    // ...
+}
+
+// 正确示例2：使用安全整数运算库
+void AllocateBufferSafe(int count, int itemSize)
+{
+    int totalSize;
+    if (!base::CheckMul(count, itemSize).AssignIfValid(&totalSize)) {
+        LOGE("Multiplication overflow");
+        return;
+    }
+    char* buffer = new char[totalSize];
+    // ...
+}
+
+// 正确示例3：使用saturated_cast
+void ProcessData(int offset, int length)
+{
+    int64_t end = base::saturated_cast<int64_t>(offset) + 
+                  base::saturated_cast<int64_t>(length);
+    if (end > INT_MAX || end < offset) {
+        LOGE("Addition overflow");
+        return;
+    }
+    for (int i = offset; i < static_cast<int>(end); i++) {
+        ProcessItem(i);
+    }
+}
+
+// 正确示例4：使用64位中间值
+int64_t CalculateBufferSize(int width, int height, int bpp)
+{
+    int64_t size = static_cast<int64_t>(width) * 
+                   static_cast<int64_t>(height) * 
+                   static_cast<int64_t>(bpp);
+    if (size > INT_MAX || size <= 0) {
+        LOGE("Buffer size overflow or invalid");
+        return -1;
+    }
+    return static_cast<int>(size);
+}
+```
+
+## 检测范围
+
+检查以下运算模式：
+
+- `a * b`、`a * b * c` 等乘法运算
+- `a + b`、`a + b + c` 等加法运算
+- `a - b` 减法运算（特别是无符号类型）
+- 内存分配大小计算：`malloc(a * b)`、`new char[a * b]`
+- 数组索引计算：`array[a + b]`、`array[a * b]`
+
+## 检测要点
+
+1. 识别算术运算表达式（+、-、*）
+2. 检查是否在内存分配上下文中使用
+3. 检查是否在数组索引上下文中使用
+4. 检查是否存在溢出保护机制
+5. 排除NOPROTECT标记的代码
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: 整数运算表达式
+- **RISK_TYPE**: 整数溢出/回绕
+- **RISK_PATH**: 运算结果溢出 -> 数值回绕 -> 内存分配错误/数组越界
+- **IMPACT_POINT**: 内存损坏、安全漏洞、程序崩溃
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: 运算结果超出类型表示范围
+- **Propagation**: 结果回绕为负值或意外大值
+- **Consequence**: 内存分配不足、缓冲区溢出、数据损坏
+- **Mitigation**: 使用安全整数运算库或添加溢出检查
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 已有溢出检查 | 存在 INT_MAX、溢出函数调用 | 不报 |
+| 第三方库 | 位于 third_party 目录 | 白名单排除 |
+| 测试代码 | 位于 test 目录 | 自动跳过 |
+| 常量运算 | 编译期可计算的表达式 | 不报 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_BoundaryCondition_011_trigger.cpp
+void trigger_bad_1(int count, int itemSize)
+{
+    int total = count * itemSize;  // 应该报：乘法溢出风险
+    char* buffer = new char[total];
+}
+
+void trigger_bad_2(int a, int b, int c)
+{
+    int size = a * b * c;  // 应该报：多次乘法溢出风险
+    ProcessBuffer(size);
+}
+
+void trigger_bad_3(uint32_t start, uint32_t end)
+{
+    uint32_t size = end - start;  // 应该报：无符号减法回绕风险
+    char* buffer = new char[size];
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_BoundaryCondition_011_safe.cpp
+void safe_good_1(int count, int itemSize)
+{
+    if (itemSize > 0 && count <= INT_MAX / itemSize) {  // 安全：有溢出检查
+        int total = count * itemSize;
+        char* buffer = new char[total];
+    }
+}
+
+void safe_good_2(int count, int itemSize)
+{
+    int total = base::saturated_cast<int>(
+        static_cast<int64_t>(count) * itemSize);  // 安全：使用saturated
+    char* buffer = new char[total];
+}
+
+// NOPROTECT: 常量运算不会溢出
+void noprotect_case()
+{
+    const int SIZE = 10 * 20;  // 编译期常量，不报
+    char buffer[SIZE];
+}
+```