@ohos-graphics/stability-code-review 0.1.0

package/references/BoundaryCondition/StabilityCodeReview_BoundaryCondition_012.md

@@ -0,0 +1,210 @@
+---
+rule_id: "StabilityCodeReview_BoundaryCondition_012"
+name: "使用json库获取键值内容前应先判断类型是否匹配、键值是否存在"
+category: "边界条件"
+severity: "MEDIUM"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 使用json库获取键值内容前应先判断类型是否匹配、键值是否存在
+
+## 问题描述
+
+直接访问json对象的键值而不检查键是否存在或类型是否匹配，可能导致程序崩溃、异常抛出或数据错误。恶意构造的json数据可能包含错误的类型，导致服务不可用。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 错误示例1：直接访问键值不检查存在性
+void ParseConfig(const Json::Value& config)
+{
+    std::string name = config["name"].asString();  // 危险：键可能不存在
+    int port = config["port"].asInt();  // 危险：同上
+}
+
+// 错误示例2：不检查类型直接转换
+void ProcessJson(const Json::Value& data)
+{
+    int count = data["count"].asInt();  // 危险：可能是其他类型
+    std::string value = data["value"].asString();  // 危险：同上
+}
+
+// 错误示例3：嵌套json访问
+void ParseNested(const Json::Value& root)
+{
+    int id = root["user"]["id"].asInt();  // 危险：user可能不存在
+    std::string name = root["user"]["profile"]["name"].asString();  // 危险：多层不检查
+}
+
+// 错误示例4：数组访问
+void ProcessArray(const Json::Value& arr, int index)
+{
+    std::string item = arr[index].asString();  // 危险：可能越界或类型不匹配
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 正确示例1：先检查键是否存在
+void ParseConfig(const Json::Value& config)
+{
+    if (!config.isMember("name") || !config["name"].isString()) {
+        LOGE("Invalid or missing 'name' field");
+        return;
+    }
+    std::string name = config["name"].asString();
+    
+    if (!config.isMember("port") || !config["port"].isInt()) {
+        LOGE("Invalid or missing 'port' field");
+        return;
+    }
+    int port = config["port"].asInt();
+}
+
+// 正确示例2：使用安全的get方法
+void ProcessJson(const Json::Value& data)
+{
+    int count = data.get("count", 0).asInt();  // 提供默认值
+    std::string value = data.get("value", "").asString();
+    
+    // 或者先检查类型
+    if (data.isMember("count") && data["count"].isInt()) {
+        int count = data["count"].asInt();
+    }
+}
+
+// 正确示例3：嵌套json安全访问
+void ParseNested(const Json::Value& root)
+{
+    if (!root.isMember("user") || !root["user"].isObject()) {
+        LOGE("Missing or invalid 'user' object");
+        return;
+    }
+    const Json::Value& user = root["user"];
+    
+    if (!user.isMember("id") || !user["id"].isInt()) {
+        LOGE("Missing or invalid 'user.id'");
+        return;
+    }
+    int id = user["id"].asInt();
+}
+
+// 正确示例4：数组安全访问
+void ProcessArray(const Json::Value& arr, int index)
+{
+    if (!arr.isArray() || index < 0 || index >= arr.size()) {
+        LOGE("Invalid array or index");
+        return;
+    }
+    if (!arr[index].isString()) {
+        LOGE("Array element is not string");
+        return;
+    }
+    std::string item = arr[index].asString();
+}
+```
+
+## 检测范围
+
+检查以下模式：
+
+- `json["key"]` 直接访问后调用 `.asXxx()`
+- `json[key]` 变量作为键访问
+- 嵌套访问 `json["a"]["b"]["c"]`
+- 数组访问 `json[index]`
+- 类型转换方法：`asString()`、`asInt()`、`asDouble()`、`asBool()`、`asArray()`、`asObject()`
+
+## 检测要点
+
+1. 识别json键值访问表达式
+2. 检查是否在访问前调用了 `isMember()`、`has()`、`contains()`
+3. 检查是否在转换前调用了类型检查方法：`isString()`、`isInt()` 等
+4. 检查是否使用了安全的 `get()` 方法
+5. 排除NOPROTECT标记的代码
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: json对象键值访问
+- **RISK_TYPE**: 键不存在/类型不匹配
+- **RISK_PATH**: 直接访问键值 -> 键不存在或类型错误 -> 异常/崩溃
+- **IMPACT_POINT**: 服务异常、程序崩溃
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: 访问不存在的键或类型不匹配的值
+- **Propagation**: 抛出异常或返回错误默认值
+- **Consequence**: 程序崩溃、服务不可用、数据错误
+- **Mitigation**: 访问前检查键存在性和类型匹配性
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 已有检查 | 存在 isMember、isXxx 调用 | 不报 |
+| 使用get方法 | 使用 .get() 安全方法 | 不报 |
+| 第三方库 | 位于 third_party 目录 | 白名单排除 |
+| 测试代码 | 位于 test 目录 | 自动跳过 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_BoundaryCondition_012_trigger.cpp
+void trigger_bad_1(const Json::Value& config)
+{
+    std::string name = config["name"].asString();  // 应该报：未检查键存在性和类型
+}
+
+void trigger_bad_2(const Json::Value& data)
+{
+    int count = data["count"].asInt();  // 应该报：未检查类型
+}
+
+void trigger_bad_3(const Json::Value& root)
+{
+    int id = root["user"]["id"].asInt();  // 应该报：嵌套访问未检查
+}
+
+void trigger_bad_4(const Json::Value& arr, int idx)
+{
+    std::string item = arr[idx].asString();  // 应该报：数组访问未检查
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_BoundaryCondition_012_safe.cpp
+void safe_good_1(const Json::Value& config)
+{
+    if (config.isMember("name") && config["name"].isString()) {  // 安全：有检查
+        std::string name = config["name"].asString();
+    }
+}
+
+void safe_good_2(const Json::Value& data)
+{
+    int count = data.get("count", 0).asInt();  // 安全：使用默认值
+}
+
+void safe_good_3(const Json::Value& root)
+{
+    if (root.isMember("user") && root["user"].isObject()) {  // 安全：有检查
+        const Json::Value& user = root["user"];
+        if (user.isMember("id") && user["id"].isInt()) {
+            int id = user["id"].asInt();
+        }
+    }
+}
+
+// NOPROTECT: 已确认数据格式正确
+void noprotect_case(const Json::Value& data)
+{
+    std::string value = data["value"].asString();  // 已确认格式
+}
+```

package/references/BoundaryCondition/StabilityCodeReview_BoundaryCondition_013.md

@@ -0,0 +1,226 @@
+---
+rule_id: "StabilityCodeReview_BoundaryCondition_013"
+name: "使用json库获取键值后，在进行类型转换前应先校验参数类型"
+category: "边界条件"
+severity: "MEDIUM"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 使用json库获取键值后，在进行类型转换前应先校验参数类型
+
+## 问题描述
+
+获取json值后直接进行类型转换，未校验实际类型是否与期望类型匹配，可能导致类型转换异常、数据错误或程序崩溃。恶意构造的json数据可能包含错误类型，造成服务异常。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 错误示例1：获取值后直接转换类型
+void ProcessValue(const Json::Value& data)
+{
+    int count = data["count"].asInt();  // 危险：未检查是否为int类型
+    std::string name = data["name"].asString();  // 危险：未检查是否为string类型
+}
+
+// 错误示例2：假设类型进行转换
+void ParseConfig(const Json::Value& config)
+{
+    double value = config["value"].asDouble();  // 危险：可能是int或string
+    bool enabled = config["enabled"].asBool();  // 危险：可能是string "true"
+}
+
+// 错误示例3：强制类型转换
+void HandleData(const Json::Value& json)
+{
+    const Json::Value& arr = json["items"];
+    for (int i = 0; i < arr.size(); i++) {
+        std::string item = arr[i].asString();  // 危险：元素可能不是string
+    }
+}
+
+// 错误示例4：static_cast转换
+void ConvertValue(const Json::Value& data)
+{
+    int64_t id = static_cast<int64_t>(data["id"].asInt64());  // 危险：未检查类型
+    float rate = static_cast<float>(data["rate"].asDouble());  // 危险：未检查类型
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 正确示例1：转换前检查类型
+void ProcessValue(const Json::Value& data)
+{
+    if (!data["count"].isInt()) {
+        LOGE("'count' is not an integer");
+        return;
+    }
+    int count = data["count"].asInt();
+    
+    if (!data["name"].isString()) {
+        LOGE("'name' is not a string");
+        return;
+    }
+    std::string name = data["name"].asString();
+}
+
+// 正确示例2：使用isXxx系列方法
+void ParseConfig(const Json::Value& config)
+{
+    if (config["value"].isDouble()) {
+        double value = config["value"].asDouble();
+    } else if (config["value"].isInt()) {
+        double value = static_cast<double>(config["value"].asInt());
+    } else if (config["value"].isString()) {
+        // 处理字符串转换
+    } else {
+        LOGE("Invalid 'value' type");
+    }
+    
+    if (config["enabled"].isBool()) {
+        bool enabled = config["enabled"].asBool();
+    } else if (config["enabled"].isString()) {
+        bool enabled = (config["enabled"].asString() == "true");
+    }
+}
+
+// 正确示例3：数组元素类型检查
+void HandleData(const Json::Value& json)
+{
+    const Json::Value& arr = json["items"];
+    if (!arr.isArray()) {
+        LOGE("'items' is not an array");
+        return;
+    }
+    for (int i = 0; i < arr.size(); i++) {
+        if (!arr[i].isString()) {
+            LOGE("Item %d is not string", i);
+            continue;
+        }
+        std::string item = arr[i].asString();
+    }
+}
+
+// 正确示例4：结合null检查
+void ConvertValue(const Json::Value& data)
+{
+    if (data["id"].isNull()) {
+        LOGE("'id' is null");
+        return;
+    }
+    if (!data["id"].isInt64() && !data["id"].isInt()) {
+        LOGE("'id' is not an integer type");
+        return;
+    }
+    int64_t id = data["id"].asInt64();
+}
+```
+
+## 检测范围
+
+检查以下类型转换方法：
+
+- `asString()` - 转换为字符串
+- `asInt()`、`asInt64()` - 转换为整数
+- `asUInt()`、`asUInt64()` - 转换为无符号整数
+- `asDouble()`、`asFloat()` - 转换为浮点数
+- `asBool()` - 转换为布尔值
+- `asArray()` - 转换为数组
+- `asObject()` - 转换为对象
+- `static_cast<T>(value.asXxx())` - 强制类型转换
+
+## 检测要点
+
+1. 识别 `.asXxx()` 类型转换调用
+2. 检查是否在转换前调用了对应的 `isXxx()` 方法
+3. 检查是否使用了安全的默认值方法
+4. 检查 `static_cast` 前是否有类型校验
+5. 排除NOPROTECT标记的代码
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: json值类型转换
+- **RISK_TYPE**: 类型转换异常
+- **RISK_PATH**: 未校验类型 -> 强制转换 -> 数据错误或异常
+- **IMPACT_POINT**: 数据损坏、程序崩溃
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: 类型不匹配时进行强制转换
+- **Propagation**: 数据被错误解释或抛出异常
+- **Consequence**: 数据损坏、程序异常、服务不可用
+- **Mitigation**: 转换前使用 `isXxx()` 方法校验类型
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 已有类型检查 | 存在 isXxx() 调用 | 不报 |
+| 使用get默认值 | 使用 .get() 安全方法 | 不报 |
+| 第三方库 | 位于 third_party 目录 | 白名单排除 |
+| 测试代码 | 位于 test 目录 | 自动跳过 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_BoundaryCondition_013_trigger.cpp
+void trigger_bad_1(const Json::Value& data)
+{
+    int count = data["count"].asInt();  // 应该报：未检查类型
+}
+
+void trigger_bad_2(const Json::Value& config)
+{
+    std::string name = config["name"].asString();  // 应该报：未检查类型
+}
+
+void trigger_bad_3(const Json::Value& json)
+{
+    double value = json["value"].asDouble();  // 应该报：未检查类型
+}
+
+void trigger_bad_4(const Json::Value& arr)
+{
+    for (int i = 0; i < arr.size(); i++) {
+        std::string item = arr[i].asString();  // 应该报：未检查元素类型
+    }
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_BoundaryCondition_013_safe.cpp
+void safe_good_1(const Json::Value& data)
+{
+    if (data["count"].isInt()) {  // 安全：有类型检查
+        int count = data["count"].asInt();
+    }
+}
+
+void safe_good_2(const Json::Value& config)
+{
+    if (config.isMember("name") && config["name"].isString()) {  // 安全：有检查
+        std::string name = config["name"].asString();
+    }
+}
+
+void safe_good_3(const Json::Value& json)
+{
+    if (json["value"].isDouble() || json["value"].isInt()) {  // 安全：有类型检查
+        double value = json["value"].asDouble();
+    }
+}
+
+// NOPROTECT: 已确认数据格式
+void noprotect_case(const Json::Value& data)
+{
+    int id = data["id"].asInt();  // 已确认类型正确
+}
+```

package/references/BoundaryCondition/StabilityCodeReview_BoundaryCondition_014.md

@@ -0,0 +1,222 @@
+---
+rule_id: "StabilityCodeReview_BoundaryCondition_014"
+name: "类型强制转换未校验，可能导致越界读"
+category: "边界条件"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 类型强制转换未校验，可能导致越界读
+
+## 问题描述
+
+类型强制转换时未校验数值范围，可能导致数据截断、数值错误或越界读取。大类型转小类型时，源值超出目标类型范围会造成数据丢失和潜在的安全问题。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 错误示例1：大整数转小整数
+void ProcessValue(int64_t bigValue)
+{
+    int smallValue = (int)bigValue;  // 危险：可能截断
+    array[smallValue] = data;  // 可能导致越界
+}
+
+// 错误示例2：size_t转int
+void AccessBuffer(size_t index, int offset)
+{
+    int idx = (int)index + offset;  // 危险：size_t可能超过INT_MAX
+    buffer[idx] = value;
+}
+
+// 错误示例3：无符号转有符号
+void ProcessIndex(uint32_t unsignedIndex)
+{
+    int signedIndex = (int)unsignedIndex;  // 危险：若unsignedIndex > INT_MAX，变为负数
+    array[signedIndex] = data;  // 可能越界访问
+}
+
+// 错误示例4：指针强制转换
+void HandlePointer(void* ptr)
+{
+    int* intPtr = (int*)ptr;  // 危险：未检查对齐和有效性
+    *intPtr = 0;  // 可能崩溃
+}
+
+// 错误示例5：double转int
+void ConvertCoordinate(double coord)
+{
+    int pixel = (int)coord;  // 危险：double可能超出int范围
+    screen[pixel] = color;
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 正确示例1：添加范围检查
+void ProcessValue(int64_t bigValue)
+{
+    if (bigValue > INT_MAX || bigValue < INT_MIN) {
+        LOGE("Value out of int range: %lld", bigValue);
+        return;
+    }
+    int smallValue = static_cast<int>(bigValue);
+    array[smallValue] = data;
+}
+
+// 正确示例2：使用saturated_cast
+void AccessBuffer(size_t index, int offset)
+{
+    int idx = base::saturated_cast<int>(index) + offset;
+    if (idx < 0 || idx >= buffer_size) {
+        LOGE("Index out of range: %d", idx);
+        return;
+    }
+    buffer[idx] = value;
+}
+
+// 正确示例3：显式范围检查
+void ProcessIndex(uint32_t unsignedIndex)
+{
+    if (unsignedIndex > static_cast<uint32_t>(INT_MAX)) {
+        LOGE("Index exceeds INT_MAX: %u", unsignedIndex);
+        return;
+    }
+    int signedIndex = static_cast<int>(unsignedIndex);
+    array[signedIndex] = data;
+}
+
+// 正确示例4：安全的指针转换
+void HandlePointer(void* ptr)
+{
+    if (ptr == nullptr) {
+        LOGE("Null pointer");
+        return;
+    }
+    // 检查对齐
+    if (reinterpret_cast<uintptr_t>(ptr) % alignof(int) != 0) {
+        LOGE("Pointer not aligned for int");
+        return;
+    }
+    int* intPtr = static_cast<int*>(ptr);
+    *intPtr = 0;
+}
+
+// 正确示例5：浮点数范围检查
+void ConvertCoordinate(double coord)
+{
+    if (coord > INT_MAX || coord < INT_MIN || !std::isfinite(coord)) {
+        LOGE("Invalid coordinate: %f", coord);
+        return;
+    }
+    int pixel = static_cast<int>(coord);
+    if (pixel >= 0 && pixel < screen_size) {
+        screen[pixel] = color;
+    }
+}
+```
+
+## 检测范围
+
+检查以下类型转换：
+
+- `static_cast<小类型>(大类型值)`
+- C风格转换 `(int)`、`(short)`、`(char)` 等
+- `reinterpret_cast` 指针转换
+- `size_t` → `int`
+- `int64_t` → `int32_t`
+- `uint32_t` → `int32_t`
+- `double` → `int`
+
+## 检测要点
+
+1. 识别类型转换表达式
+2. 判断是否为大类型转小类型
+3. 检查是否有范围校验
+4. 检查是否使用了安全转换函数
+5. 排除NOPROTECT标记的代码
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: 类型强制转换
+- **RISK_TYPE**: 数值截断/越界
+- **RISK_PATH**: 大类型转小类型 -> 数值截断 -> 数据错误/越界访问
+- **IMPACT_POINT**: 数据损坏、内存越界、安全漏洞
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: 源值超出目标类型表示范围
+- **Propagation**: 数值被截断或解释为负值
+- **Consequence**: 数组越界、数据损坏、安全漏洞
+- **Mitigation**: 转换前校验数值范围
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 已有范围检查 | 存在 INT_MAX、范围比较 | 不报 |
+| 使用安全转换 | 使用 saturated_cast、checked_cast | 不报 |
+| 第三方库 | 位于 third_party 目录 | 白名单排除 |
+| 测试代码 | 位于 test 目录 | 自动跳过 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_BoundaryCondition_014_trigger.cpp
+void trigger_bad_1(int64_t bigValue)
+{
+    int smallValue = (int)bigValue;  // 应该报：未检查范围
+}
+
+void trigger_bad_2(size_t index)
+{
+    int idx = static_cast<int>(index);  // 应该报：未检查范围
+}
+
+void trigger_bad_3(uint32_t unsignedIndex)
+{
+    int signedIndex = (int)unsignedIndex;  // 应该报：可能变为负数
+    array[signedIndex] = data;
+}
+
+void trigger_bad_4(double coord)
+{
+    int pixel = (int)coord;  // 应该报：未检查范围
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_BoundaryCondition_014_safe.cpp
+void safe_good_1(int64_t bigValue)
+{
+    if (bigValue >= INT_MIN && bigValue <= INT_MAX) {  // 安全：有范围检查
+        int smallValue = static_cast<int>(bigValue);
+    }
+}
+
+void safe_good_2(size_t index)
+{
+    int idx = base::saturated_cast<int>(index);  // 安全：使用saturated_cast
+}
+
+void safe_good_3(uint32_t unsignedIndex)
+{
+    if (unsignedIndex <= static_cast<uint32_t>(INT_MAX)) {  // 安全：有范围检查
+        int signedIndex = static_cast<int>(unsignedIndex);
+    }
+}
+
+// NOPROTECT: 已确认值在范围内
+void noprotect_case(int64_t value)
+{
+    int v = (int)value;  // 已确认范围
+}
+```