AI Sec Watch

CVE-2021-29561 is a vulnerability in TensorFlow (an open source machine learning platform) where an attacker can crash a program by sending an invalid tensor (a multi-dimensional array of numbers) to the `LoadAndRemapMatrix` function instead of the expected scalar value (a single number). This causes a validation check to fail and terminates the process, creating a denial of service attack (making the system unavailable).

TensorFlow, a machine learning platform, has a vulnerability where an attacker can cause a heap buffer overflow (memory corruption from writing past allocated memory limits) in the RaggedTensorToTensor function by providing specially crafted input shapes. The bug occurs because the code uses the same index to access two different arrays, and if one array is shorter than the other, it reads or writes to invalid memory locations.

TensorFlow, an open-source machine learning platform, has a vulnerability in the `tf.raw_ops.UnicodeEncode` function that allows attackers to read data outside the bounds of a heap allocated array (memory that a program has requested to store data). The problem occurs because the code assumes the input data describes a valid sparse tensor (a matrix with mostly empty values) without properly validating it first.

TensorFlow, a machine learning platform, has a vulnerability where an attacker can cause a heap buffer overflow (a memory safety error where data is written outside its allocated space) in the `tf.raw_ops.SparseSplit` function by controlling an offset value that accesses an array.

TensorFlow (an open-source machine learning platform) has a vulnerability where an attacker can crash a system by triggering a divide-by-zero error (FPE, or floating-point exception) in a specific operation called `tf.raw_ops.SparseMatMul` when given an empty tensor (a multidimensional array with no data). This causes a denial of service attack (making the system unavailable to legitimate users).

TensorFlow, an open source machine learning platform, has a vulnerability where an attacker can cause a denial of service (making a service unavailable) by triggering a FPE (floating-point exception, a math error that crashes a program) runtime error in a specific function called `tf.raw_ops.Reverse`. The bug happens because the code divides by the first dimension of a tensor (a multi-dimensional array of numbers) without properly checking if that dimension is zero.

TensorFlow is a machine learning platform that has a vulnerability in its `tf.raw_ops.FusedBatchNorm` operation, which can be exploited by an attacker to cause a denial of service (making the system unavailable) through a FPE runtime error (a math operation that crashes when dividing by zero). The problem occurs because the code performs division based on a dimension value that users can control.

TensorFlow, an open-source machine learning platform, has a vulnerability in the `tf.raw_ops.QuantizeAndDequantizeV3` function where an attacker can read data outside the bounds of a heap allocated buffer (memory region used for dynamic storage) by exploiting an unvalidated `axis` attribute. The code fails to check the user-supplied `axis` value before using it to access array elements, potentially allowing unauthorized data access.

TensorFlow, an open-source machine learning platform, has a vulnerability where an attacker can crash the program by passing an empty tensor (a multi-dimensional array of numbers) as the `num_segments` argument to the `UnsortedSegmentJoin` operation. The code assumes this input will always be a valid scalar (a single number), so when it's empty, a safety check fails and terminates the process, causing a denial of service (making the system unavailable).