@ohos-graphics/stability-code-review 0.1.0

package/references/BoundaryCondition/StabilityCodeReview_BoundaryCondition_017.md

@@ -0,0 +1,222 @@
+---
+rule_id: "StabilityCodeReview_BoundaryCondition_017"
+name: "返回值类型不匹配风险"
+category: "边界条件"
+severity: "MEDIUM"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 返回值类型不匹配风险
+
+## 问题描述
+
+函数返回值类型与接收变量类型不匹配可能导致隐式类型转换、数值截断、符号扩展错误等问题。这类问题可能导致数据错误、逻辑异常，甚至引发安全漏洞。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：size_t返回值赋给int
+int GetBufferSize()
+{
+    size_t size = CalculateSize();  // size_t可能是unsigned long
+    return size;  // 错误：size_t赋给int，可能截断
+}
+
+// 场景2：int64返回值赋给int32
+int32_t GetId()
+{
+    int64_t id = GenerateUniqueId();  // int64_t
+    return id;  // 错误：int64_t赋给int32_t，可能截断
+}
+
+// 场景3：unsigned返回值赋给signed
+int GetCount()
+{
+    unsigned int count = GetElementCount();  // unsigned
+    return count;  // 错误：unsigned赋给int，可能产生负数错误
+}
+
+// 场景4：指针与整数混用
+int GetPointerValue()
+{
+    void* ptr = GetAddress();
+    return (int)ptr;  // 错误：指针强制转换为int，64位平台指针截断
+}
+
+// 场景5：枚举与整数不匹配
+int GetStatus()
+{
+    Status status = GetObjectStatus();  // 枚举类型
+    return status;  // 错误：枚举返回值类型不明确
+}
+
+// 场景6：函数返回bool但接收为int
+int ProcessData()
+{
+    bool result = ValidateData();  // bool返回值
+    return result;  // 错误：bool赋给int，语义不明确
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：使用匹配的类型
+size_t GetBufferSize()
+{
+    size_t size = CalculateSize();
+    return size;  // 正确：返回类型匹配
+}
+
+// 或者如果需要int，添加范围检查
+int GetBufferSize()
+{
+    size_t size = CalculateSize();
+    if (size > INT_MAX) {  // 正确：校验范围
+        return -1;  // 错误码
+    }
+    return static_cast<int>(size);
+}
+
+// 修复场景2：使用匹配的类型
+int64_t GetId()
+{
+    int64_t id = GenerateUniqueId();
+    return id;  // 正确：返回类型匹配
+}
+
+// 修复场景3：保持类型一致性
+unsigned int GetCount()
+{
+    unsigned int count = GetElementCount();
+    return count;  // 正确：返回类型匹配
+}
+
+// 或者如果需要int，添加范围检查
+int GetCount()
+{
+    unsigned int count = GetElementCount();
+    if (count > INT_MAX) {  // 正确：校验范围
+        LOGE("count overflow");
+        return -1;
+    }
+    return static_cast<int>(count);
+}
+
+// 修复场景4：使用intptr_t处理指针
+intptr_t GetPointerValue()
+{
+    void* ptr = GetAddress();
+    return reinterpret_cast<intptr_t>(ptr);  // 正确：intptr_t保证能容纳指针
+}
+
+// 修复场景5：明确枚举返回类型
+Status GetStatus()
+{
+    Status status = GetObjectStatus();
+    return status;  // 正确：返回枚举类型
+}
+
+// 修复场景6：保持bool语义
+bool ProcessData()
+{
+    bool result = ValidateData();
+    return result;  // 正确：返回bool类型
+}
+```
+
+## 检测范围
+
+检查以下模式：
+
+- `size_t` / `ssize_t` 返回值赋给 `int`
+- `int64_t` / `uint64_t` 返回值赋给 `int32_t`
+- `unsigned` 返回值赋给 `signed` 类型
+- 指针类型强制转换为整数类型
+- 枚举类型返回值赋给整数
+- `bool` 返回值赋给 `int`
+
+## 检测要点
+
+1. 识别函数返回值类型
+2. 检查接收变量类型是否匹配
+3. 判断是否存在隐式类型转换风险
+4. 检查是否有范围校验（如 INT_MAX 检查）
+5. 排除明确标记为安全的强制转换
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**：类型不匹配的返回值赋值
+- **RISK_TYPE**：隐式类型转换错误
+- **RISK_PATH**：返回值类型不匹配 → 隐式转换 → 数值截断或符号错误 → 数据错误
+- **IMPACT_POINT**：逻辑错误、数据损坏、潜在安全漏洞
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**：返回值超出目标类型范围
+- **Propagation**：数值截断、符号位改变、精度丢失
+- **Consequence**：数据错误、逻辑异常、安全漏洞
+- **Mitigation**：使用匹配类型或添加范围校验
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| 有范围校验 | 有INT_MAX等范围检查 | 不报 |
+| 明确强制转换 | 有static_cast且类型明确 | 需判断安全性 |
+| 同类型 | 返回类型和接收类型相同 | 不报 |
+| NOPROTECT标记 | // NOPROTECT 注释 | 不报 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_BoundaryCondition_017_trigger.cpp
+int trigger_bad_1()
+{
+    size_t size = CalculateSize();
+    return size;  // 应该报：size_t赋给int
+}
+
+int32_t trigger_bad_2()
+{
+    int64_t id = GenerateUniqueId();
+    return id;  // 应该报：int64_t赋给int32_t
+}
+
+int trigger_bad_3()
+{
+    unsigned count = GetElementCount();
+    return count;  // 应该报：unsigned赋给int
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_BoundaryCondition_017_safe.cpp
+size_t safe_good_1()
+{
+    size_t size = CalculateSize();
+    return size;  // 安全：类型匹配
+}
+
+int safe_good_2()
+{
+    size_t size = CalculateSize();
+    if (size <= INT_MAX) {  // 安全：有范围校验
+        return static_cast<int>(size);
+    }
+    return -1;
+}
+
+// NOPROTECT: 特殊场景
+int noprotect_case()
+{
+    unsigned count = GetElementCount();
+    return count;  // NOPROTECT标记，不报
+}
+```

package/references/BoundaryCondition/StabilityCodeReview_BoundaryCondition_018.md

@@ -0,0 +1,336 @@
+---
+rule_id: "StabilityCodeReview_BoundaryCondition_018"
+name: "JSON解析安全风险"
+category: "边界条件"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# JSON解析安全风险
+
+## 问题描述
+
+JSON解析存在多种安全风险：解析深度过大导致栈溢出、超大JSON导致内存耗尽、未捕获解析异常、键不存在导致的空指针访问、类型不匹配导致的类型混淆、以及数值溢出问题。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：无深度限制导致栈溢出
+void ParseNestedJson(const std::string& jsonStr)
+{
+    Json::Value root;
+    Json::Reader reader;
+    reader.parse(jsonStr, root);  // 错误：未限制解析深度，恶意嵌套JSON可致栈溢出
+    
+    ProcessJson(root);
+}
+
+// 场景2：超大JSON未限制导致内存耗尽
+void LoadLargeJson(const char* filePath)
+{
+    std::ifstream file(filePath);
+    Json::Value root;
+    Json::Reader reader;
+    reader.parse(file, root);  // 错误：未限制JSON大小，超大文件可耗尽内存
+}
+
+// 场景3：未捕获解析异常
+void ParseJsonData(const std::string& jsonStr)
+{
+    Json::Value root;
+    Json::Reader reader;
+    if (!reader.parse(jsonStr, root)) {
+        // 错误：parse失败但未记录错误信息，继续使用root可能访问无效数据
+        ProcessData(root);
+    }
+}
+
+// 场景4：键不存在导致空指针访问
+void GetValueFromJson(const Json::Value& root)
+{
+    int id = root["id"].asInt();  // 错误：键可能不存在，访问无效Json::Value
+    std::string name = root["name"].asString();  // 错误：键可能不存在
+}
+
+// 场景5：类型不匹配导致错误
+void ParseTypedData(const Json::Value& root)
+{
+    int count = root["count"].asInt();  // 错误：count可能是字符串，类型混淆
+    double value = root["value"].asDouble();  // 错误：value可能是数组
+}
+
+// 场景6：数值溢出
+void ParseLargeNumber(const Json::Value& root)
+{
+    int32_t id = root["id"].asInt();  // 错误：id可能超过int32_t范围，溢出
+    size_t size = root["size"].asUInt();  // 错误：size可能是负数或超大值
+}
+
+// 场景7：数组越界访问
+void ParseArrayData(const Json::Value& root)
+{
+    const Json::Value& arr = root["items"];
+    for (int i = 0; i < 10; i++) {  // 错误：固定循环次数，arr可能少于10个元素
+        ProcessItem(arr[i]);  // 错误：可能越界访问
+    }
+}
+
+// 场景8：未检查解析成功状态
+void UseJsonResult(const std::string& jsonStr)
+{
+    Json::Value root;
+    Json::Reader reader;
+    reader.parse(jsonStr, root);  // 错误：未检查parse返回值
+    
+    int value = root["value"].asInt();  // root可能无效
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：限制解析深度
+void ParseNestedJson(const std::string& jsonStr)
+{
+    Json::Value root;
+    Json::Reader reader;
+    
+    Json::Features features;
+    features.allowNestedDepth_ = 100;  // 正确：限制嵌套深度
+    reader.parse(jsonStr, root, features);
+    
+    ProcessJson(root);
+}
+
+// 修复场景2：限制JSON大小
+void LoadLargeJson(const char* filePath)
+{
+    std::ifstream file(filePath);
+    
+    // 正确：限制文件大小
+    file.seekg(0, std::ios::end);
+    std::streamsize size = file.tellg();
+    file.seekg(0, std::ios::beg);
+    
+    const size_t MAX_JSON_SIZE = 10 * 1024 * 1024;  // 10MB限制
+    if (size > MAX_JSON_SIZE) {
+        LOGE("JSON file too large: %lld", size);
+        return;
+    }
+    
+    Json::Value root;
+    Json::Reader reader;
+    reader.parse(file, root);
+}
+
+// 修复场景3：捕获并处理解析错误
+void ParseJsonData(const std::string& jsonStr)
+{
+    Json::Value root;
+    Json::Reader reader;
+    
+    if (!reader.parse(jsonStr, root)) {
+        LOGE("JSON parse failed: %s", reader.getFormattedErrorMessages().c_str());  // 正确：记录错误信息
+        return;
+    }
+    
+    ProcessData(root);
+}
+
+// 修复场景4：检查键存在性
+void GetValueFromJson(const Json::Value& root)
+{
+    if (!root.isMember("id") || !root["id"].isInt()) {  // 正确：检查键存在和类型
+        LOGE("Missing or invalid 'id' field");
+        return;
+    }
+    int id = root["id"].asInt();
+    
+    if (!root.isMember("name") || !root["name"].isString()) {  // 正确：检查键存在和类型
+        LOGE("Missing or invalid 'name' field");
+        return;
+    }
+    std::string name = root["name"].asString();
+}
+
+// 修复场景5：检查类型匹配
+void ParseTypedData(const Json::Value& root)
+{
+    if (root.isMember("count") && root["count"].isInt()) {  // 正确：检查类型
+        int count = root["count"].asInt();
+    }
+    
+    if (root.isMember("value") && root["value"].isDouble()) {  // 正确：检查类型
+        double value = root["value"].asDouble();
+    }
+}
+
+// 修复场景6：检查数值范围
+void ParseLargeNumber(const Json::Value& root)
+{
+    if (root.isMember("id") && root["id"].isInt()) {
+        Json::Int64 id64 = root["id"].asInt64();  // 正确：使用Int64避免溢出
+        
+        if (id64 >= INT32_MIN && id64 <= INT32_MAX) {  // 正确：检查范围
+            int32_t id = static_cast<int32_t>(id64);
+        }
+    }
+    
+    if (root.isMember("size") && root["size"].isUInt()) {
+        Json::UInt64 size64 = root["size"].asUInt64();  // 正确：使用UInt64
+        
+        if (size64 <= SIZE_MAX) {  // 正确：检查范围
+            size_t size = static_cast<size_t>(size64);
+        }
+    }
+}
+
+// 修复场景7：检查数组大小
+void ParseArrayData(const Json::Value& root)
+{
+    if (!root.isMember("items") || !root["items"].isArray()) {  // 正确：检查键和类型
+        return;
+    }
+    
+    const Json::Value& arr = root["items"];
+    for (Json::ArrayIndex i = 0; i < arr.size(); i++) {  // 正确：使用实际大小
+        ProcessItem(arr[i]);
+    }
+}
+
+// 修复场景8：检查解析成功状态
+void UseJsonResult(const std::string& jsonStr)
+{
+    Json::Value root;
+    Json::Reader reader;
+    
+    bool success = reader.parse(jsonStr, root);  // 正确：检查返回值
+    if (!success) {
+        LOGE("JSON parse failed");
+        return;
+    }
+    
+    if (root.isMember("value") && root["value"].isInt()) {  // 正确：检查字段
+        int value = root["value"].asInt();
+    }
+}
+```
+
+## 检测范围
+
+检查以下模式：
+
+- JSON解析未限制嵌套深度
+- JSON解析未限制文件/字符串大小
+- JSON解析失败后继续使用root对象
+- 访问JSON键前未检查键是否存在（isMember）
+- 转换JSON值前未检查类型匹配（isXxx）
+- 数值转换可能导致溢出（asInt转int32_t）
+- JSON数组访问前未检查数组大小
+
+## 检测要点
+
+1. 识别JSON解析函数调用（parse、parseFromStream）
+2. 检查是否有深度限制设置（allowNestedDepth）
+3. 检查是否有大小限制检查
+4. 检查是否检查parse返回值
+5. 检查是否在访问键前调用isMember
+6. 检查是否在类型转换前调用isXxx
+7. 检查数组访问是否使用size()判断边界
+8. 排除NOPROTECT标记
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**：JSON解析操作
+- **RISK_TYPE**：栈溢出/内存耗尽/空指针/类型混淆/数值溢出
+- **RISK_PATH**：恶意构造JSON → 解析未限制 → 资源耗尽或数据错误 → 程序崩溃
+- **IMPACT_POINT**：栈溢出崩溃、OOM崩溃、空指针崩溃、数据损坏
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**：恶意构造的JSON输入触发各种安全问题
+- **Propagation**：栈溢出、内存耗尽、无效数据访问、数值溢出
+- **Consequence**：程序崩溃、拒绝服务、数据损坏、安全漏洞
+- **Mitigation**：限制深度和大小、检查返回值、验证键和类型、使用安全的数值类型
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| 有深度限制 | 设置allowNestedDepth | 不报 |
+| 有大小检查 | 有文件大小判断 | 不报 |
+| 有parse返回值检查 | 有 if (!parse()) | 不报 |
+| 有键检查 | 有 isMember() | 不报 |
+| 有类型检查 | 有 isXxx() | 不报 |
+| 有数组边界检查 | 使用 arr.size() | 不报 |
+| NOPROTECT标记 | // NOPROTECT 注释 | 不报 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_BoundaryCondition_018_trigger.cpp
+void trigger_bad_1(const std::string& jsonStr)
+{
+    Json::Value root;
+    Json::Reader reader;
+    reader.parse(jsonStr, root);  // 应该报：未限制深度
+}
+
+void trigger_bad_2(const Json::Value& root)
+{
+    int id = root["id"].asInt();  // 应该报：键未检查存在性
+}
+
+void trigger_bad_3(const Json::Value& root)
+{
+    int count = root["count"].asInt();  // 应该报：类型未检查
+}
+
+void trigger_bad_4(const Json::Value& root)
+{
+    const Json::Value& arr = root["items"];
+    for (int i = 0; i < 10; i++) {
+        ProcessItem(arr[i]);  // 应该报：数组越界访问
+    }
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_BoundaryCondition_018_safe.cpp
+void safe_good_1(const std::string& jsonStr)
+{
+    Json::Value root;
+    Json::Reader reader;
+    
+    Json::Features features;
+    features.allowNestedDepth_ = 100;  // 安全：有深度限制
+    reader.parse(jsonStr, root, features);
+}
+
+void safe_good_2(const Json::Value& root)
+{
+    if (root.isMember("id") && root["id"].isInt()) {  // 安全：有键和类型检查
+        int id = root["id"].asInt();
+    }
+}
+
+void safe_good_3(const Json::Value& root)
+{
+    const Json::Value& arr = root["items"];
+    for (Json::ArrayIndex i = 0; i < arr.size(); i++) {  // 安全：使用size()判断边界
+        ProcessItem(arr[i]);
+    }
+}
+
+// NOPROTECT: 特殊场景
+void noprotect_case(const Json::Value& root)
+{
+    int id = root["id"].asInt();  // NOPROTECT标记，不报
+}
+```