@ohos-graphics/stability-code-review 0.1.0

package/references/BoundaryCondition/StabilityCodeReview_BoundaryCondition_015.md

@@ -0,0 +1,256 @@
+---
+rule_id: "StabilityCodeReview_BoundaryCondition_015"
+name: "数组下标的计算应避免整数回绕导致内存越界访问"
+category: "边界条件"
+severity: "HIGH"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 数组下标的计算应避免整数回绕导致内存越界访问
+
+## 问题描述
+
+数组下标计算时若存在整数溢出或回绕，可能导致产生非法下标值，造成内存越界访问。无符号整数减法回绕尤其危险，可能产生超大值导致严重的内存安全问题。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 错误示例1：无符号整数减法回绕
+void ProcessRange(uint32_t start, uint32_t end)
+{
+    uint32_t size = end - start;  // 危险：若end < start，回绕到超大值
+    char* buffer = new char[size];
+    memcpy(buffer, data, size);  // 可能分配超大内存或越界
+}
+
+// 错误示例2：乘法溢出作为下标
+void AllocateMatrix(int width, int height)
+{
+    int index = width * height;  // 危险：可能溢出
+    buffer[index] = value;  // 可能越界访问
+}
+
+// 错误示例3：加法溢出作为下标
+void AccessBuffer(int base, int offset)
+{
+    int index = base + offset;  // 危险：可能溢出
+    array[index] = data;  // 可能越界
+}
+
+// 错误示例4：复杂表达式下标
+void ProcessBuffer(int a, int b, int c)
+{
+    int idx = a * b + c;  // 危险：多次运算可能溢出
+    buffer[idx] = value;
+}
+
+// 错误示例5：无符号减法用于数组访问
+void CopyItems(uint32_t count, uint32_t start)
+{
+    for (uint32_t i = 0; i < count; i++) {
+        uint32_t idx = start - 1 + i;  // 危险：start=0时回绕
+        array[idx] = items[i];
+    }
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 正确示例1：检查无符号减法
+void ProcessRange(uint32_t start, uint32_t end)
+{
+    if (end < start) {
+        LOGE("Invalid range: end < start");
+        return;
+    }
+    uint32_t size = end - start;
+    if (size > MAX_BUFFER_SIZE) {
+        LOGE("Size too large: %u", size);
+        return;
+    }
+    char* buffer = new char[size];
+    memcpy(buffer, data, size);
+}
+
+// 正确示例2：安全乘法
+void AllocateMatrix(int width, int height)
+{
+    if (width <= 0 || height <= 0) {
+        LOGE("Invalid dimensions");
+        return;
+    }
+    if (width > INT_MAX / height) {
+        LOGE("Multiplication overflow");
+        return;
+    }
+    int index = width * height;
+    if (index >= buffer_size) {
+        LOGE("Index out of range");
+        return;
+    }
+    buffer[index] = value;
+}
+
+// 正确示例3：安全加法
+void AccessBuffer(int base, int offset)
+{
+    if (offset > 0 && base > INT_MAX - offset) {
+        LOGE("Addition overflow");
+        return;
+    }
+    if (offset < 0 && base < INT_MIN - offset) {
+        LOGE("Addition underflow");
+        return;
+    }
+    int index = base + offset;
+    if (index < 0 || index >= array_size) {
+        LOGE("Index out of range: %d", index);
+        return;
+    }
+    array[index] = data;
+}
+
+// 正确示例4：使用64位中间值
+void ProcessBuffer(int a, int b, int c)
+{
+    int64_t idx = static_cast<int64_t>(a) * b + c;
+    if (idx < 0 || idx >= buffer_size) {
+        LOGE("Index out of range: %lld", idx);
+        return;
+    }
+    buffer[static_cast<size_t>(idx)] = value;
+}
+
+// 正确示例5：安全的无符号运算
+void CopyItems(uint32_t count, uint32_t start)
+{
+    if (start == 0) {
+        LOGE("Invalid start index");
+        return;
+    }
+    for (uint32_t i = 0; i < count; i++) {
+        uint32_t idx = start - 1 + i;
+        if (idx >= array_size) {
+            LOGE("Index out of range: %u", idx);
+            return;
+        }
+        array[idx] = items[i];
+    }
+}
+```
+
+## 检测范围
+
+检查以下下标计算模式：
+
+- `array[a + b]` - 加法下标
+- `array[a - b]` - 减法下标（尤其无符号）
+- `array[a * b]` - 乘法下标
+- `array[a * b + c]` - 复合表达式下标
+- `uint` 类型减法表达式
+
+## 检测要点
+
+1. 识别数组访问表达式
+2. 检测下标中是否包含算术运算
+3. 判断是否为危险的无符号减法
+4. 检查是否有边界检查
+5. 检查是否使用了安全运算函数
+6. 排除NOPROTECT标记的代码
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**: 数组下标计算表达式
+- **RISK_TYPE**: 整数溢出/回绕
+- **RISK_PATH**: 下标计算溢出 -> 产生非法值 -> 内存越界访问
+- **IMPACT_POINT**: 内存破坏、信息泄露、安全漏洞
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**: 下标计算结果超出数组范围
+- **Propagation**: 整数回绕产生非法下标值
+- **Consequence**: 越界读写、内存破坏、安全漏洞
+- **Mitigation**: 使用安全整数运算库，添加边界检查
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| NOPROTECT 标记 | 有 // NOPROTECT 注释 | 不报 |
+| 已有边界检查 | 存在范围比较、size检查 | 不报 |
+| 使用安全运算 | 使用 SAFE_ADD、SafeMul 等 | 不报 |
+| 第三方库 | 位于 third_party 目录 | 白名单排除 |
+| 测试代码 | 位于 test 目录 | 自动跳过 |
+| 常量下标 | 编译期可计算的常量 | 不报 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_BoundaryCondition_015_trigger.cpp
+void trigger_bad_1(uint32_t start, uint32_t end)
+{
+    uint32_t size = end - start;  // 应该报：无符号减法可能回绕
+    char* buf = new char[size];
+}
+
+void trigger_bad_2(int a, int b)
+{
+    int idx = a * b;  // 应该报：乘法可能溢出
+    buffer[idx] = value;
+}
+
+void trigger_bad_3(int base, int offset)
+{
+    int idx = base + offset;  // 应该报：加法可能溢出
+    array[idx] = data;
+}
+
+void trigger_bad_4(uint32_t count, uint32_t start)
+{
+    uint32_t idx = start - 1;  // 应该报：无符号减法可能回绕
+    array[idx] = 0;
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_BoundaryCondition_015_safe.cpp
+void safe_good_1(uint32_t start, uint32_t end)
+{
+    if (end < start) {  // 安全：有边界检查
+        return;
+    }
+    uint32_t size = end - start;
+    char* buf = new char[size];
+}
+
+void safe_good_2(int a, int b)
+{
+    if (a > 0 && b > 0 && a <= INT_MAX / b) {  // 安全：有溢出检查
+        int idx = a * b;
+        if (idx < buffer_size) {
+            buffer[idx] = value;
+        }
+    }
+}
+
+void safe_good_3(int base, int offset)
+{
+    int idx = SafeAdd(base, offset);  // 安全：使用安全运算函数
+    if (idx >= 0 && idx < array_size) {
+        array[idx] = data;
+    }
+}
+
+// NOPROTECT: 下标已确认在范围内
+void noprotect_case(int idx)
+{
+    buffer[idx] = value;  // 已确认idx合法
+}
+```

package/references/BoundaryCondition/StabilityCodeReview_BoundaryCondition_016.md

@@ -0,0 +1,269 @@
+---
+rule_id: "StabilityCodeReview_BoundaryCondition_016"
+name: "内存操作越界风险"
+category: "边界条件"
+severity: "CRITICAL"
+language: ["cpp", "c++"]
+author: "OH-Department7 Stability Team"
+---
+
+# 内存操作越界风险
+
+## 问题描述
+
+代码在执行内存拷贝（memcpy / memmove / std::copy）、指针偏移（base + offset）、数组索引（arr[idx]）或类似内存操作时，长度、偏移或下标参数来自外部可控输入（文件、网络、IPC、库返回值），未校验其是否在目标缓冲区的有效范围内。攻击者构造特定输入可触发越界读/写，造成内存破坏或任意地址写。
+
+## 检测示例
+
+### ❌ 问题代码
+
+```cpp
+// 场景1：memcpy长度来自外部未校验
+void CopyData(const char* source, size_t length)
+{
+    char buffer[1024];
+    memcpy(buffer, source, length);  // 错误：length未校验，可能超过buffer大小
+}
+
+// 场景2：指针偏移未校验范围
+void AccessOffset(Data* base, int offset)
+{
+    Data* target = base + offset;  // 错误：offset未校验，可能越界
+    target->value = 100;
+}
+
+// 场景3：数组下标来自Parcel未校验
+void ProcessParcel(Parcel* parcel)
+{
+    int index = parcel->ReadInt32();  // 来自Parcel，不可信
+    int arr[100];
+    arr[index] = 100;  // 错误：index未校验，可能越界访问
+}
+
+// 场景4：网络数据长度未校验
+void ProcessNetworkPacket(const char* packet, size_t packetSize)
+{
+    char* buffer = new char[1024];
+    memcpy(buffer, packet, packetSize);  // 错误：packetSize可能超过1024
+    delete[] buffer;
+}
+
+// 场景5：std::copy长度未校验
+void CopyVector(const std::vector<int>& source, size_t count)
+{
+    int dest[100];
+    std::copy(source.begin(), source.begin() + count, dest);  // 错误：count未校验
+}
+
+// 场景6：realloc后使用原大小访问
+void ResizeAndAccess(char* buffer, int oldSize, int newSize)
+{
+    char* newBuffer = (char*)realloc(buffer, newSize);
+    if (newBuffer == nullptr) {
+        return;
+    }
+    
+    for (int i = 0; i < oldSize; i++) {  // 错误：使用oldSize访问，但缓冲区可能已缩小
+        newBuffer[i] = '\0';
+    }
+}
+```
+
+### ✅ 修复方案
+
+```cpp
+// 修复场景1：memcpy前校验长度
+void CopyData(const char* source, size_t length)
+{
+    char buffer[1024];
+    if (length > sizeof(buffer)) {  // 正确：校验长度不超过缓冲区大小
+        LOGE("length exceeds buffer size");
+        return;
+    }
+    memcpy(buffer, source, length);
+}
+
+// 修复场景2：指针偏移前校验范围
+void AccessOffset(Data* base, int offset, size_t arraySize)
+{
+    if (offset < 0 || offset >= arraySize) {  // 正确：校验offset在有效范围内
+        LOGE("invalid offset");
+        return;
+    }
+    Data* target = base + offset;
+    target->value = 100;
+}
+
+// 修复场景3：Parcel数据校验后使用
+void ProcessParcel(Parcel* parcel)
+{
+    int index = parcel->ReadInt32();
+    int arr[100];
+    if (index < 0 || index >= 100) {  // 正确：校验index在数组范围内
+        LOGE("invalid index");
+        return;
+    }
+    arr[index] = 100;
+}
+
+// 修复场景4：网络数据大小校验
+void ProcessNetworkPacket(const char* packet, size_t packetSize)
+{
+    const size_t MAX_PACKET_SIZE = 1024;
+    if (packetSize > MAX_PACKET_SIZE) {  // 正确：校验packetSize不超过限制
+        LOGE("packet too large");
+        return;
+    }
+    
+    char* buffer = new char[packetSize];  // 使用packetSize分配
+    memcpy(buffer, packet, packetSize);
+    delete[] buffer;
+}
+
+// 修复场景5：std::copy前校验count
+void CopyVector(const std::vector<int>& source, size_t count)
+{
+    int dest[100];
+    if (count > source.size() || count > 100) {  // 正确：校验count不超过源和目标大小
+        LOGE("invalid count");
+        return;
+    }
+    std::copy(source.begin(), source.begin() + count, dest);
+}
+
+// 修复场景6：realloc后使用新大小访问
+void ResizeAndAccess(char* buffer, int oldSize, int newSize)
+{
+    char* newBuffer = (char*)realloc(buffer, newSize);
+    if (newBuffer == nullptr) {
+        free(buffer);
+        return;
+    }
+    
+    int accessSize = (newSize < oldSize) ? newSize : oldSize;  // 正确：使用安全的访问大小
+    for (int i = 0; i < accessSize; i++) {
+        newBuffer[i] = '\0';
+    }
+}
+```
+
+## 检测范围
+
+检查以下模式：
+
+- `memcpy(dest, src, len)` - len来自外部输入未校验
+- `memmove(dest, src, len)` - len来自外部输入未校验
+- `std::copy(begin, end, dest)` - end与begin的距离来自外部输入
+- `指针 + offset` - offset来自外部输入未校验
+- `数组[index]` - index来自Parcel/网络/文件等外部输入
+- `memset(ptr, value, len)` - len来自外部输入未校验
+- `realloc(ptr, size)` - size来自外部输入未校验
+
+## 检测要点
+
+1. 识别内存操作函数调用（memcpy、memmove、std::copy等）
+2. 检查长度/偏移/下标参数的来源（Parcel、网络、文件、参数）
+3. 判断是否在操作前有范围校验（if判断、assert、clamp等）
+4. 检查是否与缓冲区大小比较
+5. 排除NOPROTECT标记和已知安全的常量值
+
+## 风险流分析（RiskFlow）
+
+- **RISK_SOURCE**：外部可控的长度/偏移/下标参数
+- **RISK_TYPE**：内存越界访问
+- **RISK_PATH**：外部输入恶意构造 → 未校验直接使用 → 越界读写 → 内存破坏
+- **IMPACT_POINT**：程序崩溃、数据损坏、任意地址读写、安全漏洞
+
+## 影响分析（ImpactAnalysis）
+
+- **Trigger**：恶意构造的输入值超出缓冲区范围
+- **Propagation**：越界读写相邻内存或任意地址
+- **Consequence**：内存破坏、程序崩溃、潜在任意代码执行
+- **Mitigation**：所有外部输入的长度/偏移/下标必须校验范围
+
+## 误报排除
+
+| 场景 | 识别特征 | 处理方式 |
+|------|----------|----------|
+| 常量长度 | length是编译期常量或constexpr | 不报 |
+| 已有校验 | 有if判断或assert校验范围 | 不报 |
+| 使用sizeof | length = sizeof(buffer) | 不报 |
+| 使用容器size | length = vector.size() 且容器大小受控 | 需上下文分析 |
+| NOPROTECT标记 | // NOPROTECT 注释 | 不报 |
+| 测试代码 | 文件名包含 _test.cpp | 白名单排除 |
+## 测试用例
+
+### 触发用例（应该报）
+
+```cpp
+// test_BoundaryCondition_016_trigger.cpp
+void trigger_bad_1(Parcel* parcel)
+{
+    int index = parcel->ReadInt32();  // 应该报：Parcel数据未校验作为数组下标
+    int arr[100];
+    arr[index] = 100;
+}
+
+void trigger_bad_2(const char* data, size_t len)
+{
+    char buffer[1024];
+    memcpy(buffer, data, len);  // 应该报：len未校验，可能越界
+}
+
+void trigger_bad_3(Data* base, int offset)
+{
+    Data* target = base + offset;  // 应该报：offset未校验
+    target->value = 100;
+}
+
+void trigger_bad_4(const char* packet, size_t packetSize)
+{
+    char* buffer = new char[1024];
+    memcpy(buffer, packet, packetSize);  // 应该报：packetSize未校验
+    delete[] buffer;
+}
+```
+
+### 安全用例（不应该报）
+
+```cpp
+// test_BoundaryCondition_016_safe.cpp
+void safe_good_1(Parcel* parcel)
+{
+    int index = parcel->ReadInt32();
+    int arr[100];
+    if (index >= 0 && index < 100) {  // 安全：有范围校验
+        arr[index] = 100;
+    }
+}
+
+void safe_good_2(const char* data, size_t len)
+{
+    char buffer[1024];
+    if (len <= sizeof(buffer)) {  // 安全：有长度校验
+        memcpy(buffer, data, len);
+    }
+}
+
+void safe_good_3(Data* base, int offset, size_t size)
+{
+    if (offset >= 0 && offset < size) {  // 安全：有偏移校验
+        Data* target = base + offset;
+        target->value = 100;
+    }
+}
+
+void safe_good_4()
+{
+    char buffer[1024];
+    memcpy(buffer, source, 512);  // 安全：长度是常量
+}
+
+// NOPROTECT: 特殊场景
+void noprotect_case(Parcel* parcel)
+{
+    int index = parcel->ReadInt32();
+    int arr[100];
+    arr[index] = 100;  // NOPROTECT标记，不报
+}
+```