@ohos-graphics/stability-code-review 0.1.0

package/references/BoundaryCondition/StabilityCodeReview_BoundaryCondition_003.md

@@ -0,0 +1,305 @@
+---
+rule_id: "StabilityCodeReview_BoundaryCondition_003"
+name: "Parcel数据不可直接作为内存申请大小"
+category: "边界条件"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# Parcel数据不可直接作为内存申请大小
+
+## 问题描述
+
+从Parcel中读取的数据不可信，不能直接作为内存申请大小的值，否则可能造成内存超大申请，导致内存耗尽、程序崩溃或拒绝服务攻击。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 错误示例1：Parcel数据直接用于malloc
+void* AllocateBuffer(Parcel& parcel)
+{
+    size_t size = parcel.ReadUint32();  // 不可信数据
+    void* buffer = malloc(size);  // 危险：size可能为超大值
+    return buffer;
+}
+
+// 错误示例2：Parcel数据用于new数组
+int* CreateIntArray(Parcel& parcel)
+{
+    int count = parcel.ReadInt32();
+    int* arr = new int[count];  // 危险：count可能为超大值
+    return arr;
+}
+
+// 错误示例3：Parcel数据用于std::vector初始化
+std::vector<char> ReadVector(Parcel& parcel)
+{
+    uint32_t size = parcel.ReadUint32();
+    std::vector<char> vec(size);  // 危险：size可能为超大值
+    return vec;
+}
+
+// 错误示例4：Parcel数据用于std::string分配
+std::string ReadString(Parcel& parcel)
+{
+    uint32_t len = parcel.ReadUint32();
+    std::string str;
+    str.resize(len);  // 危险：len可能为超大值
+    parcel.ReadBuffer(static_cast<void*>(&str[0]), len);
+    return str;
+}
+
+// 错误示例5：Parcel数据用于realloc
+void* ResizeBuffer(Parcel& parcel, void* oldPtr, size_t oldSize)
+{
+    size_t newSize = parcel.ReadUint32();
+    void* newPtr = realloc(oldPtr, newSize);  // 危险：newSize可能为超大值
+    return newPtr;
+}
+
+// 错误示例6：多级内存申请叠加
+void** CreateBufferArray(Parcel& parcel)
+{
+    int count = parcel.ReadInt32();
+    void** arr = new void*[count];  // 危险1：count可能超大
+    for (int i = 0; i < count; i++) {
+        size_t bufSize = parcel.ReadUint32();
+        arr[i] = malloc(bufSize);  // 危险2：bufSize可能超大
+    }
+    return arr;
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 正确示例1：添加上限检查
+constexpr size_t MAX_BUFFER_SIZE = 10 * 1024 * 1024;  // 10MB
+
+void* AllocateBuffer(Parcel& parcel)
+{
+    size_t size = parcel.ReadUint32();
+    if (size == 0 || size > MAX_BUFFER_SIZE) {
+        LOGE("Invalid buffer size: %zu, max allowed: %zu", size, MAX_BUFFER_SIZE);
+        return nullptr;
+    }
+    void* buffer = malloc(size);
+    if (buffer == nullptr) {
+        LOGE("malloc failed for size: %zu", size);
+    }
+    return buffer;
+}
+
+// 正确示例2：限制数组大小
+constexpr int MAX_ARRAY_COUNT = 100000;
+
+int* CreateIntArray(Parcel& parcel)
+{
+    int count = parcel.ReadInt32();
+    if (count <= 0 || count > MAX_ARRAY_COUNT) {
+        LOGE("Invalid array count: %d, max allowed: %d", count, MAX_ARRAY_COUNT);
+        return nullptr;
+    }
+    int* arr = new (std::nothrow) int[count];
+    if (arr == nullptr) {
+        LOGE("new failed for count: %d", count);
+    }
+    return arr;
+}
+
+// 正确示例3：安全的vector初始化
+constexpr uint32_t MAX_VECTOR_SIZE = 1024 * 1024;  // 1M elements
+
+std::vector<char> ReadVector(Parcel& parcel)
+{
+    uint32_t size = parcel.ReadUint32();
+    if (size == 0 || size > MAX_VECTOR_SIZE) {
+        LOGE("Invalid vector size: %u", size);
+        return std::vector<char>();
+    }
+    std::vector<char> vec;
+    vec.reserve(size);  // 使用reserve而非直接初始化
+    return vec;
+}
+
+// 正确示例4：安全的string处理
+constexpr uint32_t MAX_STRING_LEN = 1024 * 1024;  // 1MB
+
+std::string ReadString(Parcel& parcel)
+{
+    uint32_t len = parcel.ReadUint32();
+    if (len == 0 || len > MAX_STRING_LEN) {
+        LOGE("Invalid string length: %u", len);
+        return "";
+    }
+    std::string str;
+    str.resize(len);
+    if (parcel.ReadBuffer(static_cast<void*>(&str[0]), len) != len) {
+        LOGE("Failed to read string data");
+        return "";
+    }
+    return str;
+}
+
+// 正确示例5：安全的realloc
+void* ResizeBuffer(Parcel& parcel, void* oldPtr, size_t oldSize)
+{
+    size_t newSize = parcel.ReadUint32();
+    if (newSize == 0 || newSize > MAX_BUFFER_SIZE) {
+        LOGE("Invalid new size: %zu", newSize);
+        return oldPtr;  // 保持原有指针
+    }
+    void* newPtr = realloc(oldPtr, newSize);
+    if (newPtr == nullptr) {
+        LOGE("realloc failed");
+        return oldPtr;
+    }
+    return newPtr;
+}
+
+// 正确示例6：分级内存申请保护
+constexpr int MAX_BUFFER_COUNT = 1000;
+constexpr size_t MAX_INDIVIDUAL_BUFFER_SIZE = 1024 * 1024;
+constexpr size_t MAX_TOTAL_BUFFER_SIZE = 100 * 1024 * 1024;  // 100MB total
+
+void** CreateBufferArray(Parcel& parcel)
+{
+    int count = parcel.ReadInt32();
+    if (count <= 0 || count > MAX_BUFFER_COUNT) {
+        LOGE("Invalid buffer count: %d", count);
+        return nullptr;
+    }
+    
+    void** arr = new (std::nothrow) void*[count];
+    if (arr == nullptr) {
+        LOGE("Failed to allocate buffer array");
+        return nullptr;
+    }
+    
+    size_t totalAllocated = 0;
+    for (int i = 0; i < count; i++) {
+        size_t bufSize = parcel.ReadUint32();
+        if (bufSize == 0 || bufSize > MAX_INDIVIDUAL_BUFFER_SIZE) {
+            LOGE("Invalid buffer size: %zu", bufSize);
+            continue;
+        }
+        totalAllocated += bufSize;
+        if (totalAllocated > MAX_TOTAL_BUFFER_SIZE) {
+            LOGE("Total allocation exceeded limit");
+            break;
+        }
+        arr[i] = malloc(bufSize);
+    }
+    return arr;
+}
+```
+
+## 检测范围
+
+检查以下模式：
+
+1. Parcel数据用于`malloc/calloc/realloc`
+2. Parcel数据用于`new/new[]`
+3. Parcel数据用于`std::vector`初始化
+4. Parcel数据用于`std::string::resize/reserve`
+5. Parcel数据用于容器`resize/reserve`
+
+## 检测要点
+
+1. 识别Parcel读取函数：`ReadInt32`, `ReadUint32`, `ReadInt64`, `ReadUint64`
+2. 追踪读取变量到内存申请函数
+3. 检查是否进行了上限保护
+4. 识别`malloc`, `calloc`, `realloc`, `new`, `new[]`, `vector`, `string`等
+5. 排除NOPROTECT标记的代码
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: Parcel读取的不可信数据
+- **RISK_TYPE**: 内存超大申请
+- **RISK_PATH**: 不可信数据 -> 内存申请大小 -> 内存耗尽
+- **IMPACT_POINT**: 系统资源耗尽、拒绝服务
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: Parcel数据直接用于内存申请大小
+- **Propagation**: 恶意构造超大数值导致大量内存申请
+- **Consequence**: 内存耗尽、程序崩溃、系统不稳定
+- **Mitigation**: 添加内存申请上限检查，分级限制
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 已有上限检查 | 存在常量比较或条件判断 | 不报 |
+| 安全分配函数 | 使用自定义安全分配器 | 不报 |
+| 第三方库 | 位于 third_party 目录 | 白名单排除 |
+| 测试代码 | 位于 test 目录 | 自动跳过 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_BoundaryCondition_003_trigger.cpp
+void* trigger_bad_1(Parcel& parcel)
+{
+    size_t size = parcel.ReadUint32();
+    return malloc(size);  // 应该报：无上限检查
+}
+
+int* trigger_bad_2(Parcel& parcel)
+{
+    int count = parcel.ReadInt32();
+    return new int[count];  // 应该报：无上限检查
+}
+
+std::vector<int> trigger_bad_3(Parcel& parcel)
+{
+    uint32_t size = parcel.ReadUint32();
+    return std::vector<int>(size);  // 应该报：无上限检查
+}
+
+void trigger_bad_4(Parcel& parcel)
+{
+    uint32_t len = parcel.ReadUint32();
+    std::string str;
+    str.resize(len);  // 应该报：无上限检查
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_BoundaryCondition_003_safe.cpp
+constexpr size_t MAX_SIZE = 10 * 1024 * 1024;
+
+void* safe_good_1(Parcel& parcel)
+{
+    size_t size = parcel.ReadUint32();
+    if (size == 0 || size > MAX_SIZE) {  // 安全：有上限检查
+        LOGE("Invalid size");
+        return nullptr;
+    }
+    return malloc(size);
+}
+
+int* safe_good_2(Parcel& parcel)
+{
+    int count = parcel.ReadInt32();
+    if (count <= 0 || count > 1000) {  // 安全：有上限检查
+        LOGE("Invalid count");
+        return nullptr;
+    }
+    return new (std::nothrow) int[count];
+}
+
+// NOPROTECT: 特殊场景需要大内存
+void* noprotect_case(Parcel& parcel)
+{
+    size_t size = parcel.ReadUint32();
+    return malloc(size);
+}
+```

package/references/BoundaryCondition/StabilityCodeReview_BoundaryCondition_004.md

@@ -0,0 +1,350 @@
+---
+rule_id: "StabilityCodeReview_BoundaryCondition_004"
+name: "容器size增长的对外接口应限制上限"
+category: "边界条件"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 容器size增长的对外接口应限制上限
+
+## 问题描述
+
+会导致容器size增大的对外接口，应该限制容器size的上限，防止外部恶意攻击申请过大内存。外部输入可能包含恶意构造的数据，导致容器无限增长，造成内存耗尽或拒绝服务。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 错误示例1：push_back无限制
+class DataProcessor {
+private:
+    std::vector<int> data_;
+public:
+    void AddData(int value) {
+        data_.push_back(value);  // 危险：无大小限制
+    }
+};
+
+// 错误示例2：从外部数据源批量添加
+class MessageHandler {
+private:
+    std::vector<Message> messages_;
+public:
+    void AddMessages(const std::vector<Message>& msgs) {
+        for (const auto& msg : msgs) {
+            messages_.push_back(msg);  // 危险：无大小限制
+        }
+    }
+};
+
+// 错误示例3：insert操作无限制
+class ConnectionManager {
+private:
+    std::set<Connection*> connections_;
+public:
+    void AddConnection(Connection* conn) {
+        connections_.insert(conn);  // 危险：无大小限制
+    }
+};
+
+// 错误示例4：从Parcel读取无限制
+class DataManager {
+private:
+    std::vector<std::string> items_;
+public:
+    void ReadFromParcel(Parcel& parcel) {
+        int count = parcel.ReadInt32();
+        for (int i = 0; i < count; i++) {
+            items_.push_back(parcel.ReadString());  // 危险：count和items_都无限制
+        }
+    }
+};
+
+// 错误示例5：map插入无限制
+class CacheManager {
+private:
+    std::map<int, Data> cache_;
+public:
+    void Insert(int key, const Data& data) {
+        cache_[key] = data;  // 危险：无大小限制
+    }
+};
+
+// 错误示例6：链表无限制增长
+class EventQueue {
+private:
+    std::list<Event> events_;
+public:
+    void PushEvent(const Event& event) {
+        events_.push_back(event);  // 危险：无大小限制
+    }
+};
+```
+
+### ✅ 修复方案
+
+```cpp
+// 正确示例1：添加容量限制
+class DataProcessor {
+private:
+    std::vector<int> data_;
+    static constexpr size_t MAX_DATA_SIZE = 10000;
+    
+public:
+    bool AddData(int value) {
+        if (data_.size() >= MAX_DATA_SIZE) {
+            LOGE("Data size exceeded limit: %zu", MAX_DATA_SIZE);
+            return false;
+        }
+        data_.push_back(value);
+        return true;
+    }
+};
+
+// 正确示例2：批量添加时检查总大小
+class MessageHandler {
+private:
+    std::vector<Message> messages_;
+    static constexpr size_t MAX_MESSAGES = 5000;
+    
+public:
+    bool AddMessages(const std::vector<Message>& msgs) {
+        if (messages_.size() + msgs.size() > MAX_MESSAGES) {
+            LOGE("Message count exceeded limit");
+            return false;
+        }
+        for (const auto& msg : msgs) {
+            messages_.push_back(msg);
+        }
+        return true;
+    }
+};
+
+// 正确示例3：连接数限制
+class ConnectionManager {
+private:
+    std::set<Connection*> connections_;
+    static constexpr size_t MAX_CONNECTIONS = 1000;
+    
+public:
+    bool AddConnection(Connection* conn) {
+        if (connections_.size() >= MAX_CONNECTIONS) {
+            LOGE("Connection count exceeded limit: %zu", MAX_CONNECTIONS);
+            return false;
+        }
+        auto result = connections_.insert(conn);
+        if (!result.second) {
+            LOGE("Connection already exists");
+            return false;
+        }
+        return true;
+    }
+};
+
+// 正确示例4：安全的Parcel读取
+class DataManager {
+private:
+    std::vector<std::string> items_;
+    static constexpr size_t MAX_ITEMS = 1000;
+    static constexpr size_t MAX_ITEM_COUNT = 100;
+    
+public:
+    bool ReadFromParcel(Parcel& parcel) {
+        int count = parcel.ReadInt32();
+        if (count < 0 || static_cast<size_t>(count) > MAX_ITEM_COUNT) {
+            LOGE("Invalid count: %d", count);
+            return false;
+        }
+        if (items_.size() + count > MAX_ITEMS) {
+            LOGE("Items size exceeded limit");
+            return false;
+        }
+        for (int i = 0; i < count; i++) {
+            items_.push_back(parcel.ReadString());
+        }
+        return true;
+    }
+};
+
+// 正确示例5：缓存大小限制
+class CacheManager {
+private:
+    std::map<int, Data> cache_;
+    static constexpr size_t MAX_CACHE_SIZE = 10000;
+    
+public:
+    bool Insert(int key, const Data& data) {
+        if (cache_.size() >= MAX_CACHE_SIZE) {
+            // 可选：淘汰策略
+            EvictOldest();
+        }
+        if (cache_.size() >= MAX_CACHE_SIZE) {
+            LOGE("Cache is full");
+            return false;
+        }
+        cache_[key] = data;
+        return true;
+    }
+    
+private:
+    void EvictOldest() {
+        if (!cache_.empty()) {
+            cache_.erase(cache_.begin());
+        }
+    }
+};
+
+// 正确示例6：事件队列大小限制
+class EventQueue {
+private:
+    std::list<Event> events_;
+    static constexpr size_t MAX_QUEUE_SIZE = 10000;
+    
+public:
+    bool PushEvent(const Event& event) {
+        if (events_.size() >= MAX_QUEUE_SIZE) {
+            LOGE("Event queue is full, dropping oldest event");
+            events_.pop_front();
+        }
+        events_.push_back(event);
+        return true;
+    }
+    
+    bool PushEventNoDrop(const Event& event) {
+        if (events_.size() >= MAX_QUEUE_SIZE) {
+            LOGE("Event queue is full");
+            return false;
+        }
+        events_.push_back(event);
+        return true;
+    }
+};
+```
+
+## 检测范围
+
+检查以下模式：
+
+1. 公共接口中的`push_back/push_front/insert/emplace`
+2. 公共接口中的容器扩展操作
+3. 公共接口从外部数据源添加元素
+4. 公共接口处理批量数据
+
+## 检测要点
+
+1. 识别`public`成员函数中的容器操作
+2. 检测`push_back`, `push_front`, `insert`, `emplace`等操作
+3. 检查是否进行了大小限制
+4. 识别`std::vector`, `std::list`, `std::map`, `std::set`, `std::deque`等容器
+5. 排除NOPROTECT标记的代码
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: 外部输入数据
+- **RISK_TYPE**: 容器大小无限制
+- **RISK_PATH**: 外部数据 -> 容器增长 -> 内存耗尽
+- **IMPACT_POINT**: 系统资源耗尽、拒绝服务
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: 对外接口未限制容器大小增长
+- **Propagation**: 恶意大量调用导致容器无限增长
+- **Consequence**: 内存耗尽、程序崩溃、系统不稳定
+- **Mitigation**: 添加容器大小上限检查，实现淘汰策略
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 已有大小检查 | 存在 size() 比较或容量检查 | 不报 |
+| 私有成员函数 | 标记为 private/protected | 不报 |
+| 内部工具类 | 明确标记为内部使用 | 不报 |
+| 第三方库 | 位于 third_party 目录 | 白名单排除 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_BoundaryCondition_004_trigger.cpp
+class TriggerBad1 {
+    std::vector<int> data_;
+public:
+    void AddData(int value) {
+        data_.push_back(value);  // 应该报：无大小限制
+    }
+};
+
+class TriggerBad2 {
+    std::map<int, std::string> cache_;
+public:
+    void Insert(int key, const std::string& value) {
+        cache_[key] = value;  // 应该报：无大小限制
+    }
+};
+
+class TriggerBad3 {
+    std::list<Event> events_;
+public:
+    void PushEvent(const Event& event) {
+        events_.push_back(event);  // 应该报：无大小限制
+    }
+};
+
+class TriggerBad4 {
+    std::set<int> ids_;
+public:
+    void AddId(int id) {
+        ids_.insert(id);  // 应该报：无大小限制
+    }
+};
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_BoundaryCondition_004_safe.cpp
+class SafeGood1 {
+    std::vector<int> data_;
+    static constexpr size_t MAX_SIZE = 1000;
+public:
+    bool AddData(int value) {
+        if (data_.size() >= MAX_SIZE) {  // 安全：有大小限制
+            return false;
+        }
+        data_.push_back(value);
+        return true;
+    }
+};
+
+class SafeGood2 {
+    std::vector<int> data_;
+public:
+    void AddData(int value) {
+        if (data_.capacity() > data_.size()) {  // 安全：有容量检查
+            data_.push_back(value);
+        }
+    }
+};
+
+class SafeGood3 {
+    std::vector<int> data_;
+public:
+    void ClearAndAdd(int value) {  // 安全：先清空
+        data_.clear();
+        data_.push_back(value);
+    }
+};
+
+// NOPROTECT: 内部使用，数据量可控
+class NoprotectCase {
+    std::vector<int> data_;
+public:
+    void AddData(int value) {
+        data_.push_back(value);
+    }
+};
+```