Products / tensorflow-cpu
tensorflow-cpu
423 records.
- TensorFlow has segfault in array_ops.upper_bound Passing a tensor that is not rank 2 to upper_bound makes the op read invalid memory and crash with a segmentation fault.
- TensorFlow Denial of Service vulnerability A zero-sized dimension in the input to a Convolution3DTranspose layer triggers a CHECK failure that crashes the TensorFlow model.
- TensorFlow has Null Pointer Error in QuantizedMatMulWithBiasAndDequantize A crafted call to the quantized matmul op with MKL enabled triggers a null pointer dereference that crashes the TensorFlow process.
- TensorFlow has Null Pointer Error in SparseSparseMaximum Malformed sparse tensor inputs to SparseSparseMaximum cause a null pointer dereference that crashes the process.
- TensorFlow has Floating Point Exception in TFLite in conv kernel A crafted TFLite model with a non-positive input channel count triggers a floating-point exception during convolution kernel setup.
- TensorFlow has Floating Point Exception in TensorListSplit with XLA A crafted TensorListSplit call compiled with XLA triggers a floating point exception that crashes the process.
- TensorFlow has Null Pointer Error in TensorArrayConcatV2 A TensorArrayConcatV2 call with a null step container reaches a lookup on a null pointer, crashing the process.
- TensorFlow vulnerable to Out-of-Bounds Read in GRUBlockCellGrad Crafted tensor inputs to the GRU block cell gradient op make it read beyond the bounds of its buffer.
- TensorFlow has Heap-buffer-overflow in AvgPoolGrad AvgPoolGrad does not validate its size and stride arguments against the input shape, causing a heap buffer overflow.
- TensorFlow has null dereference on ParallelConcat with XLA A null pointer dereference in the XLA-compiled ParallelConcat op crashes the process when the shape rank is not positive.
- TensorFlow vulnerable to integer overflow in EditDistance An empty hypothesis shape causes an unsigned integer underflow in EditDistance shape handling, which makes the operation hang.
- TensorFlow has Segfault in Bincount with XLA Under XLA, a Bincount call with a weights tensor of the wrong shape crashes the process with a segmentation fault.
- TensorFlow vulnerable to Out-of-Bounds Read in DynamicStitch Mismatched indices and data shapes passed to DynamicStitch make the kernel read past the end of a stack buffer.
- TensorFlow has Null Pointer Error in LookupTableImportV2 A scalar values argument to LookupTableImportV2 triggers a null pointer dereference that crashes the process.
- TensorFlow has double free in Fractional(Max/Avg)Pool Pooling ratios with non-unit batch or channel values passed to the fractional pooling ops trigger a double free.
- TensorFlow has Floating Point Exception in AudioSpectrogram Setting the stride to zero in AudioSpectrogram causes an integer division by zero when computing the output length, crashing the process.
- TensorFlow vulnerable to segfault when opening multiframe gif A crafted multi-frame GIF overflows an integer size calculation during decoding, leading to a segmentation fault.
- TensorFlow has Null Pointer Error in RandomShuffle with XLA enable A crafted RandomShuffle call under XLA compilation dereferences a null pointer and crashes the process.
- TensorFlow has a heap out-of-buffer read vulnerability in the QuantizeAndDequantize operation An oversized axis argument to QuantizeAndDequantize ops causes an out-of-bounds heap read, which can crash the process or lead to code execution.
- TensorFlow has segmentation fault in tfg-translate Mismatched integer sizes in generic function handling cause out-of-bounds memory access when tfg-translate processes crafted input.
- TensorFlow vulnerable to seg fault in `tf.raw_ops.Print` Setting summarize to zero makes the Print operation dereference a null pointer while formatting boolean data, causing a segmentation fault.
- TensorFlow has Floating Point Exception in AvgPoolGrad with XLA Zero stride and window size passed to the AvgPoolGrad op under XLA trigger a floating point exception that crashes the process.
- Tensorflow vulnerable to Out-of-Bounds Read A true_classes entry larger than range_max makes the candidate sampler read past the end of a heap buffer.
- `CHECK` fail via inputs in `SdcaOptimizer` Inputs of the wrong rank passed to tf.raw_ops.SdcaOptimizer fail an internal CHECK, aborting the process.
- Overflow in `ResizeNearestNeighborGrad` A large size input makes the nearest-neighbour gradient kernel overflow its size calculation, corrupting memory.
- Overflow in `ImageProjectiveTransformV2` An oversized output shape causes an integer overflow in the image transform's size calculation, leading to invalid memory handling.
- Segfault in `tf.raw_ops.TensorListConcat` Passing an empty element_shape to TensorFlow's TensorListConcat op crashes the process with a segmentation fault.
- `CHECK_EQ` fail in `tf.raw_ops.TensorListResize` Passing a non-scalar size to TensorFlow's TensorListResize op trips a CHECK assertion, aborting the process.
- FPE in `tf.image.generate_bounding_box_proposals` Missing rank validation on the scores input lets a crafted call trigger a floating point exception in a GPU kernel that crashes the process.
- Overflow in `FusedResizeAndPadConv2D` A very large size argument makes FusedResizeAndPadConv2D's shape arithmetic overflow, leading to out-of-bounds memory handling.
- Overflow in `tf.keras.losses.poisson` Oversized tensor shapes cause an int32 overflow during element-wise multiplication, crashing TensorFlow during broadcast.
- Out of bounds write in grappler in Tensorflow Input and output size arguments to the Grappler function builder can be mismatched, causing an out-of-bounds memory read or a crash.
- `CHECK` failure in `SobolSample` via missing validation SobolSample receives non-scalar inputs where it assumes scalars, triggering a CHECK failure that crashes the process.
- `FractionalMaxPoolGrad` Heap out of bounds read Out-of-range pooling sequence values passed to a TensorFlow fractional max pool gradient op cause a heap out-of-bounds read that crashes the process.
- Heap overflow in `QuantizeAndDequantizeV2` Quantisation arguments with mismatched sizes and an oversized axis cause an out-of-bounds memory read in TensorFlow's Grappler function construction.
- `CHECK_EQ` fail via input in `SparseMatrixNNZ` Passing a non-matrix tensor to a sparse matrix op triggers an assertion failure that crashes the process.
- `MirrorPadGrad` heap out of bounds read Out-of-range paddings values passed to the MirrorPadGrad op make it read outside a heap buffer during gradient computation.
- `CHECK` fail in `BCast` overflow Shape values larger than int32 passed to BCast::ToShape trigger a CHECK failure that crashes the process.
- `CHECK` fail via inputs in `SparseFillEmptyRowsGrad` Passing empty inputs to the sparse fill-rows gradient op triggers a failed internal check that crashes TensorFlow.
- Seg fault in `ndarray_tensor_bridge` due to zero and large inputs Zero-sized and very large shapes produce a null array that is never checked, so the bridge crashes.
- `CHECK` fail via inputs in `PyFunc` A non-UTF-8 token passed to PyFunc trips an assertion in native code and crashes the process.
- Invalid char to bool conversion when printing a tensor Tensor printing casts raw char values to bool, which is undefined behaviour for values other than zero or one and crashes sanitizer builds.
- Segfault in `CompositeTensorVariantToComponents` Passing a malformed encoded tensor to a TensorFlow raw op makes the native kernel dereference invalid memory and crash the process.
- `tf.raw_ops.Mfcc` crashes An oversized filterbank channel count passed to the Mfcc raw op triggers an unchecked size that crashes TensorFlow.
- Out of bounds segmentation fault due to unequal op inputs in Tensorflow Calling the op with mismatched counts of indices and data tensors triggers an out-of-bounds access and a segmentation fault.
- `CHECK` fail in `TensorListScatter` and `TensorListScatterV2` in eager mode Non-scalar element_shape inputs to TensorListScatter in eager mode hit a CHECK that aborts the process.
- FractionalMaxPool and FractionalAVGPool heap out-of-bounds acess A pooling_ratio below 1 causes out-of-bounds heap access in the fractional max and average pooling kernels.
- Segfault via invalid attributes in `pywrap_tfe_src.cc` Quantized tensors passed as attribute values make the Python binding return a null pointer that is not checked, crashing the process.
- TensorFlow vulnerable to heap out of bounds read in filesystem glob matching The filesystem glob matcher indexes the directory array past its end, so a glob over a specific directory layout reads out of bounds and crashes.
- TensorFlow vulnerable to `CHECK` fail in `AvgPoolGrad` Passing a negative original input shape to the AvgPoolGrad op triggers an unvalidated CHECK failure that crashes the process.