fix security bug (#55782)

wanghuancoder · web-flow · commit 19da5c0c4d8c · 2023-08-02T15:08:19.000+08:00
* fix security bug
diff --git a/paddle/fluid/pybind/op_function_common.cc b/paddle/fluid/pybind/op_function_common.cc
@@ -412,7 +412,7 @@ std::vector<int> CastPyArg2Ints(PyObject* obj,
             i));
       }
     }
-  } else if (PySequence_Check(obj)) {
+  } else if (PySequence_Check(obj) && !PyObject_TypeCheck(obj, p_tensor_type)) {
     Py_ssize_t len = PySequence_Size(obj);
     value.reserve(len);
     PyObject* item = nullptr;
@@ -488,7 +488,7 @@ std::vector<int64_t> CastPyArg2Longs(PyObject* obj,
             i));
       }
     }
-  } else if (PySequence_Check(obj)) {
+  } else if (PySequence_Check(obj) && !PyObject_TypeCheck(obj, p_tensor_type)) {
     Py_ssize_t len = PySequence_Size(obj);
     PyObject* item = nullptr;
     for (Py_ssize_t i = 0; i < len; i++) {
@@ -567,7 +567,7 @@ std::vector<float> CastPyArg2Floats(PyObject* obj,
             i));
       }
     }
-  } else if (PySequence_Check(obj)) {
+  } else if (PySequence_Check(obj) && !PyObject_TypeCheck(obj, p_tensor_type)) {
     Py_ssize_t len = PySequence_Size(obj);
     PyObject* item = nullptr;
     for (Py_ssize_t i = 0; i < len; i++) {
@@ -642,7 +642,7 @@ std::vector<double> CastPyArg2Float64s(PyObject* obj,
             i));
       }
     }
-  } else if (PySequence_Check(obj)) {
+  } else if (PySequence_Check(obj) && !PyObject_TypeCheck(obj, p_tensor_type)) {
     Py_ssize_t len = PySequence_Size(obj);
     PyObject* item = nullptr;
     for (Py_ssize_t i = 0; i < len; i++) {
diff --git a/paddle/phi/infermeta/binary.cc b/paddle/phi/infermeta/binary.cc
@@ -2663,6 +2663,12 @@ void SearchsortedInferMeta(const MetaTensor& sorted_sequence,
                            MetaTensor* out) {
   auto sequences_dims = sorted_sequence.dims();
   auto values_dims = value.dims();
+  PADDLE_ENFORCE_GE(
+      sequences_dims.size(),
+      1,
+      phi::errors::InvalidArgument(
+          "Input sequences's dimension(%d) must be greater or equal than 1",
+          sequences_dims.size()));
 
   bool flag = true;
   if (sequences_dims.size() != values_dims.size()) {
diff --git a/paddle/phi/kernels/cpu/broadcast_kernel.cc b/paddle/phi/kernels/cpu/broadcast_kernel.cc
@@ -28,6 +28,11 @@ void BroadcastKernel(const Context& dev_ctx,
                      const DenseTensor& x,
                      int root,
                      DenseTensor* out) {
+  PADDLE_ENFORCE_GT(
+      x.numel(),
+      0,
+      phi::errors::InvalidArgument("Tensor need be broadcast must not empyt."));
+
 #if defined(PADDLE_WITH_GLOO)
   dev_ctx.template Alloc<T>(out);
   auto comm_context =
diff --git a/paddle/phi/kernels/cpu/dot_kernel.cc b/paddle/phi/kernels/cpu/dot_kernel.cc
@@ -27,6 +27,9 @@ void DotKernel(const Context& dev_ctx,
                const DenseTensor& x,
                const DenseTensor& y,
                DenseTensor* out) {
+  if (out->numel() <= 0) {
+    return;
+  }
   auto const *x_ptr = x.data<T>(), *x_ptr_ = &x_ptr[0];
   auto const *y_ptr = y.data<T>(), *y_ptr_ = &y_ptr[0];
   T* z = dev_ctx.template Alloc<T>(out);
diff --git a/paddle/phi/kernels/cpu/eig_kernel.cc b/paddle/phi/kernels/cpu/eig_kernel.cc
@@ -24,6 +24,10 @@ void EigKernel(const Context& dev_ctx,
                const DenseTensor& x,
                DenseTensor* out_w,
                DenseTensor* out_v) {
+  PADDLE_ENFORCE_GT(
+      x.numel(),
+      0,
+      errors::InvalidArgument("EigKernel input tensor is empty."));
   if (!IsComplexType(x.dtype())) {
     dev_ctx.template Alloc<phi::dtype::Complex<T>>(out_w);
     dev_ctx.template Alloc<phi::dtype::Complex<T>>(out_v);
diff --git a/paddle/phi/kernels/cpu/reduce_kernel.cc b/paddle/phi/kernels/cpu/reduce_kernel.cc
@@ -29,6 +29,10 @@ void ReduceKernel(const Context& dev_ctx,
                   int root,
                   int reduce_type,
                   DenseTensor* out) {
+  PADDLE_ENFORCE_GT(
+      x.numel(),
+      0,
+      phi::errors::InvalidArgument("Tensor need be reduced must not empyt."));
 #if defined(PADDLE_WITH_GLOO)
   out->Resize(x.dims());
   dev_ctx.template Alloc<T>(out);
diff --git a/paddle/phi/kernels/cpu/top_k_kernel.cc b/paddle/phi/kernels/cpu/top_k_kernel.cc
@@ -153,6 +153,12 @@ void TopkKernel(const Context& dev_ctx,
   }
 
   int k = k_scalar.to<int>();
+  PADDLE_ENFORCE_GE(
+      x.numel(),
+      k,
+      errors::InvalidArgument(
+          "x has only %d element, can not find %d top values.", x.numel(), k));
+
   if (k_scalar.FromTensor()) {
     auto out_dims = out->dims();
     // accroding to axis to set K value in the dim
diff --git a/paddle/phi/kernels/funcs/gather_scatter_functor.cc b/paddle/phi/kernels/funcs/gather_scatter_functor.cc
@@ -122,7 +122,6 @@ struct cpu_gather_scatter_functor {
 
           self_idx = is_scatter_like ? replace_index : index_idx;
           src_idx = is_scatter_like ? index_idx : replace_index;
-
           reduce_op((tensor_t*)(self_data + self_idx),  // NOLINT
                     (tensor_t*)(src_data + src_idx));   // NOLINT
           index_idx++;
diff --git a/paddle/phi/kernels/funcs/reduce_function.h b/paddle/phi/kernels/funcs/reduce_function.h
@@ -988,6 +988,10 @@ void ReduceKernel(const KPDevice& dev_ctx,
                   const TransformOp& transform,
                   const std::vector<int>& origin_reduce_dims,
                   bool is_mean = false) {
+  PADDLE_ENFORCE_GT(
+      x.numel(),
+      0,
+      phi::errors::InvalidArgument("Tensor need be reduced must not empyt."));
 #ifdef PADDLE_WITH_XPU_KP
   auto stream = dev_ctx.x_context()->xpu_stream;
 #else
@@ -1298,6 +1302,11 @@ void ReduceKernelImpl(const Context& dev_ctx,
                       const std::vector<int64_t>& dims,
                       bool keep_dim,
                       bool reduce_all) {
+  PADDLE_ENFORCE_GT(
+      input.numel(),
+      0,
+      phi::errors::InvalidArgument("Tensor need be reduced must not empyt."));
+
   dev_ctx.template Alloc<OutT>(output);
 
   if (reduce_all) {
diff --git a/paddle/phi/kernels/funcs/repeat_tensor2index_tensor.h b/paddle/phi/kernels/funcs/repeat_tensor2index_tensor.h
@@ -32,6 +32,11 @@ void RepeatsTensor2IndexTensor(const Context& ctx,
 
   int64_t index_size = 0;
   for (int i = 0; i < repeats.dims()[0]; i++) {
+    PADDLE_ENFORCE_GE(repeats_data[i],
+                      0,
+                      phi::errors::InvalidArgument(
+                          "repeats must grater or equal than 0, but got %d",
+                          repeats_data[i]));
     index_size += repeats_data[i];
   }
   std::vector<RepeatsT> index_vec(index_size);
diff --git a/paddle/phi/kernels/gpu/broadcast_kernel.cu b/paddle/phi/kernels/gpu/broadcast_kernel.cu
@@ -28,6 +28,11 @@ void BroadcastKernel(const Context& dev_ctx,
                      const DenseTensor& x,
                      int root,
                      DenseTensor* out) {
+  PADDLE_ENFORCE_GT(
+      x.numel(),
+      0,
+      phi::errors::InvalidArgument("Tensor need be broadcast must not empyt."));
+
 #if defined(PADDLE_WITH_NCCL) || defined(PADDLE_WITH_RCCL)
   dev_ctx.template Alloc<T>(out);
   gpuStream_t stream = dev_ctx.stream();
diff --git a/paddle/phi/kernels/gpu/dot_kernel.cu b/paddle/phi/kernels/gpu/dot_kernel.cu
@@ -31,6 +31,9 @@ void DotKernel(const Context& dev_ctx,
                const DenseTensor& x,
                const DenseTensor& y,
                DenseTensor* out) {
+  if (out->numel() <= 0) {
+    return;
+  }
   dev_ctx.template Alloc<T>(out);
   if (out->dims().size() == 0) {
     auto eigen_out = phi::EigenScalar<T>::From(*out);
diff --git a/paddle/phi/kernels/gpu/lerp_kernel.cu b/paddle/phi/kernels/gpu/lerp_kernel.cu
@@ -51,6 +51,16 @@ void LerpKernel(const Context &ctx,
                 const DenseTensor &y,
                 const DenseTensor &weight,
                 DenseTensor *out) {
+  PADDLE_ENFORCE_GT(
+      x.numel(),
+      0,
+      phi::errors::InvalidArgument("LerpKernel's input x must not empyt."));
+
+  PADDLE_ENFORCE_GT(
+      y.numel(),
+      0,
+      phi::errors::InvalidArgument("LerpKernel's input y must not empyt."));
+
   int rank = out->dims().size();
   PADDLE_ENFORCE_GE(
       rank,
diff --git a/paddle/phi/kernels/gpu/reduce_kernel.cu b/paddle/phi/kernels/gpu/reduce_kernel.cu
@@ -29,6 +29,10 @@ void ReduceKernel(const Context& dev_ctx,
                   int root,
                   int reduce_type,
                   DenseTensor* out) {
+  PADDLE_ENFORCE_GT(
+      x.numel(),
+      0,
+      phi::errors::InvalidArgument("Tensor need be reduced must not empyt."));
 #if defined(PADDLE_WITH_NCCL) || defined(PADDLE_WITH_RCCL)
   out->Resize(x.dims());
   dev_ctx.template Alloc<T>(out);
diff --git a/paddle/phi/kernels/gpu/top_k_kernel.cu b/paddle/phi/kernels/gpu/top_k_kernel.cu
@@ -77,6 +77,11 @@ void TopkKernel(const Context& dev_ctx,
   if (axis < 0) axis += in_dims.size();
 
   int k = k_scalar.to<int>();
+  PADDLE_ENFORCE_GE(
+      x.numel(),
+      k,
+      errors::InvalidArgument(
+          "x has only %d element, can not find %d top values.", x.numel(), k));
   if (k_scalar.FromTensor()) {
     phi::DDim out_dims = out->dims();
     out_dims[axis] = k;
diff --git a/paddle/phi/kernels/impl/lerp_kernel_impl.h b/paddle/phi/kernels/impl/lerp_kernel_impl.h
@@ -83,6 +83,16 @@ void LerpKernel(const Context& ctx,
                 const DenseTensor& y,
                 const DenseTensor& weight,
                 DenseTensor* out) {
+  PADDLE_ENFORCE_GT(
+      x.numel(),
+      0,
+      phi::errors::InvalidArgument("LerpKernel's input x must not empyt."));
+
+  PADDLE_ENFORCE_GT(
+      y.numel(),
+      0,
+      phi::errors::InvalidArgument("LerpKernel's input y must not empyt."));
+
   int rank = out->dims().size();
   PADDLE_ENFORCE_GE(
       rank,
diff --git a/paddle/phi/kernels/impl/repeat_interleave_kernel_impl.h b/paddle/phi/kernels/impl/repeat_interleave_kernel_impl.h
@@ -58,6 +58,11 @@ void RepeatInterleaveKernel(const Context& ctx,
                             int repeats,
                             int dim,
                             DenseTensor* out) {
+  PADDLE_ENFORCE_GT(repeats,
+                    0,
+                    phi::errors::InvalidArgument(
+                        "repeats must grater than 0, but got %d", repeats));
+
   auto place = ctx.GetPlace();
   auto cpu_place = phi::CPUPlace();
 
diff --git a/python/paddle/tensor/manipulation.py b/python/paddle/tensor/manipulation.py
@@ -543,6 +543,8 @@ def unstack(x, axis=0, num=None):
         raise ValueError(
             '`axis` must be in the range [-{0}, {0})'.format(x.ndim)
         )
+    if num is not None and (num < 0 or num > x.shape[axis]):
+        raise ValueError(f'`num` must be in the range [0, {x.shape[axis]})')
     if in_dynamic_mode():
         if num is None:
             num = x.shape[axis]
@@ -4372,7 +4374,6 @@ def repeat_interleave(x, repeats, axis=None, name=None):
     if axis is None:
         x = paddle.flatten(x)
         axis = 0
-
     if in_dynamic_mode():
         if isinstance(repeats, Variable):
             return _C_ops.repeat_interleave_with_tensor_index(x, repeats, axis)

Original file line number	Diff line number	Diff line change
`@@ -412,7 +412,7 @@ std::vector<int> CastPyArg2Ints(PyObject* obj,`
`412`	`412`	`i));`
`413`	`413`	`}`
`414`	`414`	`}`
`415`		`- } else if (PySequence_Check(obj)) {`
	`415`	`+ } else if (PySequence_Check(obj) && !PyObject_TypeCheck(obj, p_tensor_type)) {`
`416`	`416`	`Py_ssize_t len = PySequence_Size(obj);`
`417`	`417`	`value.reserve(len);`
`418`	`418`	`PyObject* item = nullptr;`
`@@ -488,7 +488,7 @@ std::vector<int64_t> CastPyArg2Longs(PyObject* obj,`
`488`	`488`	`i));`
`489`	`489`	`}`
`490`	`490`	`}`
`491`		`- } else if (PySequence_Check(obj)) {`
	`491`	`+ } else if (PySequence_Check(obj) && !PyObject_TypeCheck(obj, p_tensor_type)) {`
`492`	`492`	`Py_ssize_t len = PySequence_Size(obj);`
`493`	`493`	`PyObject* item = nullptr;`
`494`	`494`	`for (Py_ssize_t i = 0; i < len; i++) {`
`@@ -567,7 +567,7 @@ std::vector<float> CastPyArg2Floats(PyObject* obj,`
`567`	`567`	`i));`
`568`	`568`	`}`
`569`	`569`	`}`
`570`		`- } else if (PySequence_Check(obj)) {`
	`570`	`+ } else if (PySequence_Check(obj) && !PyObject_TypeCheck(obj, p_tensor_type)) {`
`571`	`571`	`Py_ssize_t len = PySequence_Size(obj);`
`572`	`572`	`PyObject* item = nullptr;`
`573`	`573`	`for (Py_ssize_t i = 0; i < len; i++) {`
`@@ -642,7 +642,7 @@ std::vector<double> CastPyArg2Float64s(PyObject* obj,`
`642`	`642`	`i));`
`643`	`643`	`}`
`644`	`644`	`}`
`645`		`- } else if (PySequence_Check(obj)) {`
	`645`	`+ } else if (PySequence_Check(obj) && !PyObject_TypeCheck(obj, p_tensor_type)) {`
`646`	`646`	`Py_ssize_t len = PySequence_Size(obj);`
`647`	`647`	`PyObject* item = nullptr;`
`648`	`648`	`for (Py_ssize_t i = 0; i < len; i++) {`