Validate negative output dimensions in Pad and Slice operators

Add checks that output dimensions are not negative after computing
them from user-supplied pads/slices. Without these checks, excessive
negative padding or slicing could produce tensors with negative
dimensions, leading to buffer underflows or undefined behavior.

Zero-sized dimensions are valid (empty tensors) and are not rejected.

Affected operators and providers:
- CPU Pad: both reshaped and true output dimensions
- CUDA Pad: output dimensions in compute loop
- WebGPU Pad: output dimensions in compute loop
- WebGPU Slice: output dimensions after ceil computation
- JS onnxjs Slice (WebGL): output shape after ends - starts
- JS onnxjs padShape utility
- JS jsep padShape utility
- JS jsep Slice (WebGPU): output shape after ceil computation

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: bmehta001

js/web/lib/onnxjs/backends/webgl/ops/slice.ts

@@ -70,6 +70,11 @@ const createSliceProgramInfo = (
   const sliceOps: string[] = [];
   for (let i = 0; i < normalizedAxes.length; i++) {
     outputShape[normalizedAxes[i]] = ends[i] - starts[i];
+    if (outputShape[normalizedAxes[i]] < 0) {
+      throw new Error(
+        `Output dimension ${normalizedAxes[i]} is negative (${outputShape[normalizedAxes[i]]}). This may occur from excessive negative slicing.`,
+      );
+    }
     if (starts[i] > 0) {
       sliceOps.push(`outputIdx[${normalizedAxes[i]}] += ${starts[i]};`);
     } // else { sliceOps.push(`outputIdx[${normalizedAxes[i]}] += 0;`); }

js/web/lib/onnxjs/util.ts

@@ -741,7 +741,15 @@ export class ShapeUtil {
    */
   static padShape(dims: readonly number[], pad: readonly number[]): readonly number[] {
     const rank = dims.length;
-    return dims.map((v, i) => v + pad[i] + pad[i + rank]);
+    return dims.map((v, i) => {
+      const nextDim = v + pad[i] + pad[i + rank];
+      if (nextDim < 0) {
+        throw new Error(
+          `Output dimension ${i} is negative (${nextDim}). This may occur from excessive negative padding.`,
+        );
+      }
+      return nextDim;
+    });
   }
 
   /**

js/web/lib/wasm/jsep/util.ts

@@ -222,7 +222,15 @@ export class ShapeUtil {
    */
   static padShape(dims: readonly number[], pad: readonly number[]): readonly number[] {
     const rank = dims.length;
-    return dims.map((v, i) => v + pad[i] + pad[i + rank]);
+    return dims.map((v, i) => {
+      const nextDim = v + pad[i] + pad[i + rank];
+      if (nextDim < 0) {
+        throw new Error(
+          `Output dimension ${i} is negative (${nextDim}). This may occur from excessive negative padding.`,
+        );
+      }
+      return nextDim;
+    });
   }
 
   /**

js/web/lib/wasm/jsep/webgpu/ops/slice.ts

@@ -166,6 +166,11 @@ const createSliceProgramInfo = (inputs: readonly TensorView[], attributes: Slice
   const outputShape = inputShape.slice(0);
   axes.forEach((axis, _) => {
     outputShape[axis] = Math.ceil((ends[axis] - starts[axis]) / steps[axis]);
+    if (outputShape[axis] < 0) {
+      throw new Error(
+        `Output dimension ${axis} is negative (${outputShape[axis]}). This may occur from excessive negative slicing.`,
+      );
+    }
   });
   const outputTensorInfo: TensorInfo = { dims: outputShape, dataType: inputs[0].dataType };
 

onnxruntime/core/providers/cpu/tensor/pad.cc

@@ -457,11 +457,17 @@ static Status PadImpl(OpKernelContext* ctx,
     effective_input_extents.push_back(extent);
     reshaped_output_dims[i] += SafeInt<int64_t>(reshaped_pad[i]) + reshaped_pad[i + new_dims_count] +
                                reshaped_slice[i] + reshaped_slice[i + new_dims_count];
+    ORT_RETURN_IF(reshaped_output_dims[i] < 0,
+                  "Output dimension ", i, " is negative (", reshaped_output_dims[i],
+                  "). This may occur from excessive negative padding/slicing.");
   }
 
   // Compute true output dimensions
   for (size_t i = 0; i < data_rank; i++) {
     output_dims[i] += SafeInt<int64_t>(pads[i]) + pads[i + data_rank] + slices[i] + slices[i + data_rank];
+    ORT_RETURN_IF(output_dims[i] < 0,
+                  "Output dimension ", i, " is negative (", output_dims[i],
+                  "). This may occur from excessive negative padding/slicing.");
   }
 
   // If the input is empty, but output shape may not be, need padding only

onnxruntime/core/providers/cuda/tensor/pad.cc

@@ -250,6 +250,9 @@ Status Pad<T>::ComputeInternal(OpKernelContext* ctx) const {
     lower_pads[i] = SafeInt<int64_t>((*p_pads)[i]) + (*p_slices)[i];
     upper_pads[i] = SafeInt<int64_t>((*p_pads)[i + dimension_count]) + (*p_slices)[i + dimension_count];
     output_dims[i] += SafeInt<int64_t>(lower_pads[i]) + upper_pads[i];
+    ORT_RETURN_IF(output_dims[i] < 0,
+                  "Output dimension ", i, " is negative (", output_dims[i],
+                  "). This may occur from excessive negative padding/slicing.");
   }
 
   TensorShapeVector effective_input_extents;

onnxruntime/core/providers/webgpu/tensor/pad.cc

@@ -68,6 +68,9 @@ Status Pad::ComputeInternal(ComputeContext& context) const {
     int64_t upper_pad = (*p_pads)[i + dimension_count] + (*p_slices)[i + dimension_count];
     lower_pads[i] = static_cast<int32_t>(lower_pad);
     output_dims[i] += lower_pad + upper_pad;
+    ORT_RETURN_IF(output_dims[i] < 0,
+                  "Output dimension ", i, " is negative (", output_dims[i],
+                  "). This may occur from excessive negative padding/slicing.");
   }
   TensorShape output_shape(output_dims);
 

onnxruntime/core/providers/webgpu/tensor/slice.cc

@@ -206,6 +206,9 @@ Status Slice::ComputeInternal(ComputeContext& context) const {
     }
     auto temp = static_cast<int64_t>(ceil(1.0 * (end - start) / static_cast<float>(step)));
     output_dims[axes[i]] = (temp > 0 && dim_value != 0) ? temp : 0;
+    ORT_RETURN_IF(output_dims[axes[i]] < 0,
+                  "Output dimension ", axes[i], " is negative (", output_dims[axes[i]],
+                  "). This may occur from excessive negative slicing.");
   }
 
   // insert missing dimensions