Products / tensorflow
tensorflow
433 records.
- Null pointer exception when `Exit` node is not preceded by `Enter` op A raw TensorFlow Exit op with no matching Enter causes graph construction to dereference a null parent pointer and crash the process.
- Overflow/crash in `tf.image.resize` when size is large An oversized resize argument overflows the computed output element count and trips a CHECK that aborts the process.
- FPE in convolutions with zero size filters Convolution kernels divide by zero when given empty filter tensors, crashing the process with a floating-point exception.
- Segfault while copying constant resource tensor Constant folding during graph optimisation attempts a deep copy of a resource tensor that should be immutable, and the copy crashes the process.
- Missing validation during checkpoint loading A tampered checkpoint file makes TensorFlow's loader process malformed data without validation, causing overflows, undefined behaviour and crashes.
- A use of uninitialized value vulnerability in Tensorflow A saved model without a dequeue node makes TensorFlow's Grappler optimizer read a variable that was never initialised.
- FPE in `ParallelConcat` A ParallelConcat call with a zero shape is not validated, so the kernel divides by zero and the process crashes.
- Integer division by 0 in `tf.raw_ops.AllToAll` A zero split_count argument makes AllToAll shape inference divide by zero during tracing, crashing the process.
- Segfault due to negative splits in `SplitV` Negative values in the split size list are not validated, so crafted arguments make the split operation segfault.
- Crash in `tf.math.segment_*` operations Passing a very large segment id to tf.math.segment_* ops overflows a shape calculation, triggering a CHECK failure that aborts the process.
- Access to invalid memory during shape inference in `Cudnn*` ops Shape inference for Cudnn RNN ops reads dimensions from inputs of unchecked rank, causing out-of-bounds heap memory access.
- Heap OOB in shape inference for `QuantizeV2` Shape inference for QuantizeV2 uses a negative axis below -1 as an index into input dimensions without bounds checking, reading memory before a heap buffer.
- Heap OOB in `FusedBatchNorm` kernels Malformed tensor shapes passed to the FusedBatchNormGrad kernel cause a heap out-of-bounds access.
- Heap OOB read in `tf.ragged.cross` Shape inference for the ragged cross op reads past a heap buffer when given crafted sparse inputs.
- Incomplete validation in `tf.summary.create_file_writer` Passing non-scalar arguments to the summary file writer constructor trips an assertion and crashes the process.
- Use after free / memory leak in `CollectiveReduceV2` An async error path in CollectiveReduceV2 uses a callback after it was moved from, causing use-after-free and memory leaks.
- Deadlock in mutually recursive `tf.function` objects A non-reentrant lock causes mutually recursive tf.function objects to deadlock when called, hanging any process that loads such a model.
- Unitialized access in `EinsumHelper::ParseEquation` The einsum equation parser does not set ellipsis flags on every path, so callers read uninitialised variables.
- Arbitrary memory read in `ImmutableConst` A crafted ImmutableConst op maps an attacker-named file as string memory, letting the attacker read arbitrary file contents.
- Heap OOB read in `tf.raw_ops.SparseCountSparseOutput` Shape inference for a sparse count op never checks the rank of its indices input, so a malformed tensor triggers an out-of-bounds heap read.
- Crash in `max_pool3d` when size argument is 0 or negative Pooling layers do not check that window sizes are positive, so a zero or negative dimension crashes the process.
- Incomplete validation of shapes in multiple TF ops Several ops skip shape validation on tensor arguments, allowing crashes and out-of-bounds heap reads or writes.
- Crashes due to overflow and `CHECK`-fail in ops with large tensor shapes Tensor shape size computations can overflow int64 and hit CHECK failures, so a crafted shape crashes the process instead of returning an error.
- `SparseFillEmptyRows` heap OOB SparseFillEmptyRows does not check that indices and values have matching sizes, so mismatched inputs cause an out-of-bounds heap read.
- Reference binding to `nullptr` in `tf.ragged.cross` Shape inference for a ragged cross op binds a reference to null, causing undefined behaviour and a crash on crafted input.
- Null pointer exception in `DeserializeSparse` A scalar input to DeserializeSparse makes shape inference dereference a null pointer and crash TensorFlow.
- Overflow/crash in `tf.range` Integer overflow from a double-typed conditional in the range and sparse eye kernels produces a crash with large inputs.
- `CHECK`-fail in `MapStage` An empty key tensor passed to tf.raw_ops.MapStage triggers a CHECK failure that aborts the process because the input is not validated.
- `std::abort` raised from `TensorListReserve` A negative num_elements passed to tf.raw_ops.TensorListReserve makes a std::vector resize to a negative size, aborting the process.
- FPE in LSH in TFLite A crafted TFLite model with a zero first input dimension causes a division by zero in the LSH projection kernel when it runs.
- Heap OOB and CHECK fail in `ResourceGather` An excessive batch_dims value makes ResourceGather read past the tensor's heap buffer because its rank check is only a debug check.
- FPE in `tf.raw_ops.UnravelIndex` A missing check for empty dimension tensors lets a crafted call to an index-unravelling op trigger division by zero and crash serving applications.
- Use after free and segfault in shape inference functions Shape and type data attached to shape-inference output references memory owned by a context that is freed early, so later access causes a use-after-free and segfault.
- Use of unitialized value in TFLite Quantized TFLite operations read quantization parameters without checking the quantization type, so they can use uninitialized pointers.
- Reference binding to nullptr in `RaggedTensorToSparse` A ragged-tensor op accepts a splits array without checking ordering, binding a reference to null and causing undefined behaviour.
- Heap OOB in `SdcaOptimizerV2` Illegal tensor arguments to an SDCA optimizer op skip a length check, letting the kernel read past the end of a heap buffer.
- Reference binding to nullptr in `MatrixDiagV*` ops Passing an empty tensor as the k argument to MatrixDiagV ops makes the kernel read the first element of nothing, causing undefined behaviour.
- Null pointer dereference in `UncompressElement` UncompressElement accepts a variant that does not hold a compressed element, so a null pointer is dereferenced during decompression.
- Reference binding to nullptr in `MatrixSetDiagV*` ops An empty tensor passed as the diagonal offset makes code read its first element through a null reference, causing undefined behaviour.
- Heap OOB in `ResourceScatterUpdate` A weak divisibility check on the shapes of indices and updates in ResourceScatterUpdate allows an out-of-bounds heap read.
- Incomplete validation in `MaxPoolGrad` Missing checks on the orig_input and orig_output tensors in MaxPoolGrad let a crafted call segfault the TensorFlow process.
- NPE in TFLite The TFLite SVDF kernel dereferences a state tensor pointer that may be null, crashing when the variable input lookup fails.
- Integer division by 0 in sparse reshaping A zero-element shape passed to SparseReshape causes an integer division by zero in the reshape functor.
- Heap OOB in `UpperBound` and `LowerBound` Crafted illegal arguments to UpperBound and LowerBound cause heap reads past the buffer because the rank of sorted_input is never validated.
- Division by 0 in most convolution operators A convolution call with zero-sized tensors reaches shape inference, which divides by zero and crashes the process, causing denial of service.
- Heap OOB in `RaggedGather` Crafted ragged tensor arguments make RaggedGather read a tensor's first dimension before checking its rank, causing an out-of-bounds heap read.
- Integer overflow due to conversion to unsigned A negative axis value is converted to unsigned and used as an allocation size in QuantizeAndDequantizeV4Grad, causing integer overflow in memory handling.
- Heap OOB in TFLite The expand-dims kernel does not check the lower bound of a negative axis, so a large negative value causes a read one element before the array start.
- Null pointer dereference in `SparseTensorSliceDataset` A sparse tensor built with empty indices but non-empty values causes a null pointer dereference during validation, crashing the process.
- Null pointer dereference in `CompressElement` Passing an empty component list to the element compression op dereferences a null buffer before validation, crashing the process.