[onert-micro] Add index bounds checks to fix security vulnerabilities

onert-micro/onert-micro/include/OMStatus.h

@@ -35,6 +35,7 @@ enum OMStatus
   FailReadWOFFile,
   FailReadCheckpointFile,
   CmsisNNError,
+  IndexError,
 };
 
 } // namespace onert_micro

onert-micro/onert-micro/include/core/OMRuntimeShape.h

@@ -123,9 +123,13 @@ class OMRuntimeShape
     if (_size == 0)
       return 0;
 
-    auto it = _dims.cbegin();
-
-    return std::accumulate(it, it + _size, 1u, std::multiplies<size_t>());
+    size_t result = 1;
+    for (size_t i = 0; i < _size; ++i)
+    {
+      if (__builtin_mul_overflow(result, static_cast<size_t>(_dims[i]), &result))
+        return 0;
+    }
+    return result;
   }
 
   // clang-format off

onert-micro/onert-micro/include/pal/common/PALGatherND.h

@@ -72,6 +72,13 @@ inline OMStatus GatherND(core::OMRuntimeShape params_shape, const ParamsT *param
     {
       int offset = i * indices_nd + j;
       IndicesT index = index_data[offset];
+
+      // Bounds check: index must be non-negative and within dimension size
+      if (index < 0 || index >= params_shape.dims(j))
+      {
+        return IndexError;
+      }
+
       from_pos += index * dims_to_count[j];
     }
     if (from_pos < 0 || from_pos + slice_size > params_flat_size)

onert-micro/onert-micro/include/pal/common/PALSlice.h

@@ -42,6 +42,18 @@ OMStatus Slice(const core::SliceParams &op_params, const core::OMRuntimeShape &i
     stop[i] = (size_count < padded_i || op_params.size[size_count - padded_i] == -1)
                 ? ext_shape.dims(i)
                 : start[i] + op_params.size[size_count - padded_i];
+
+    // Bounds check: start must be non-negative and within dimension size
+    if (start[i] < 0 || start[i] > ext_shape.dims(i))
+    {
+      return IndexError;
+    }
+
+    // Bounds check: stop must be within dimension size and >= start
+    if (stop[i] < start[i] || stop[i] > ext_shape.dims(i))
+    {
+      return IndexError;
+    }
   }
 
   for (int i0 = start[0]; i0 < stop[0]; ++i0)

onert-micro/onert-micro/src/execute/kernels/Gather.cpp

@@ -36,9 +36,9 @@ constexpr uint32_t positionsTensorIdx = 1;
 constexpr uint32_t outputTensorIdx = 0;
 
 template <typename InputT, typename CoordsT = int32_t>
-void gather(const InputT *input_data, const CoordsT *coords_data, InputT *output_data,
-            int32_t axis_size, int32_t batch_size, int32_t outer_size, int32_t inner_size,
-            int32_t coord_size)
+OMStatus gather(const InputT *input_data, const CoordsT *coords_data, InputT *output_data,
+                int32_t axis_size, int32_t batch_size, int32_t outer_size, int32_t inner_size,
+                int32_t coord_size)
 {
 
   for (int batch = 0; batch < batch_size; ++batch)
@@ -47,7 +47,14 @@ void gather(const InputT *input_data, const CoordsT *coords_data, InputT *output
     {
       for (int coord = 0; coord < coord_size; ++coord)
       {
-        auto x = coords_data[coord];
+        auto x = coords_data[batch * coord_size + coord];
+
+        // Bounds check: index must be in range [0, axis_size)
+        if (x < 0 || x >= axis_size)
+        {
+          return IndexError;
+        }
+
         std::memcpy(
           output_data + (((batch * outer_size) + outer) * coord_size + coord) * inner_size,
           input_data +
@@ -57,6 +64,8 @@ void gather(const InputT *input_data, const CoordsT *coords_data, InputT *output
       }
     }
   }
+
+  return Ok;
 }
 
 } // namespace
@@ -159,29 +168,29 @@ OMStatus execute_kernel_CircleGather(const OMExecuteArgs &execute_args)
 #ifndef DIS_FLOAT
     case circle::TensorType_FLOAT32:
     {
-      gather<float, int32_t>(utils::castInputData<float>(input_data),
-                             utils::castInputData<int32_t>(position_data),
-                             utils::castOutputData<float>(output_data), axis_size, batch_size,
-                             outer_size, inner_size, coord_size);
+      status = gather<float, int32_t>(utils::castInputData<float>(input_data),
+                                      utils::castInputData<int32_t>(position_data),
+                                      utils::castOutputData<float>(output_data), axis_size,
+                                      batch_size, outer_size, inner_size, coord_size);
     }
     break;
 #endif // DIS_FLOAT
 #ifndef DIS_QUANT
     case circle::TensorType_INT8:
     {
-      gather<int8_t, int32_t>(utils::castInputData<int8_t>(input_data),
-                              utils::castInputData<int32_t>(position_data),
-                              utils::castOutputData<int8_t>(output_data), axis_size, batch_size,
-                              outer_size, inner_size, coord_size);
+      status = gather<int8_t, int32_t>(utils::castInputData<int8_t>(input_data),
+                                       utils::castInputData<int32_t>(position_data),
+                                       utils::castOutputData<int8_t>(output_data), axis_size,
+                                       batch_size, outer_size, inner_size, coord_size);
     }
     break;
 #endif // DIS_QUANT
     case circle::TensorType_INT32:
     {
-      gather<int32_t, int32_t>(utils::castInputData<int32_t>(input_data),
-                               utils::castInputData<int32_t>(position_data),
-                               utils::castOutputData<int32_t>(output_data), axis_size, batch_size,
-                               outer_size, inner_size, coord_size);
+      status = gather<int32_t, int32_t>(utils::castInputData<int32_t>(input_data),
+                                        utils::castInputData<int32_t>(position_data),
+                                        utils::castOutputData<int32_t>(output_data), axis_size,
+                                        batch_size, outer_size, inner_size, coord_size);
     }
     break;
     default:

onert-micro/onert-micro/src/execute/kernels/Pad.cpp

@@ -113,6 +113,12 @@ OMStatus execute_kernel_CirclePad(const OMExecuteArgs &execute_args)
   {
     pad_params.left_padding[idx] = paddings_data[idx * 2];
     pad_params.right_padding[idx] = paddings_data[idx * 2 + 1];
+
+    // Bounds check: padding values must be non-negative
+    if (pad_params.left_padding[idx] < 0 || pad_params.right_padding[idx] < 0)
+    {
+      return IndexError;
+    }
   }
 
   switch (input1->type())