AI Sec Watch

TensorFlow has a vulnerability in the `FractionalAvgPool` operation where an attacker can provide specially crafted input values to cause a division by zero error (a crash caused by dividing by zero), leading to denial of service (making the system unavailable). The bug happens because user-controlled values aren't properly validated before being used in mathematical operations, allowing the computed output size to become zero.

TensorFlow, a machine learning platform, has a vulnerability where an attacker can cause a division by zero error (attempting to divide by zero, which crashes a program) in a specific operation called `tf.raw_ops.QuantizedBatchNormWithGlobalNormalization`. The bug happens because the code performs a modulo operation (finding the remainder after division) without checking if the divisor is zero first, and an attacker can craft input shapes to make this divisor equal zero.

TensorFlow, an open source machine learning platform, has a vulnerability where attackers can trigger a division by zero error (attempting to divide a number by zero, which crashes a program) in a specific operation, causing the service to become unavailable. The bug exists because the code doesn't properly check all the requirements that should be enforced before running the operation.

TensorFlow, an open source machine learning platform, has a vulnerability in a specific operation called `tf.raw_ops.QuantizedBatchNormWithGlobalNormalization` that allows attackers to crash the system by accessing memory outside intended bounds. The bug occurs when the operation receives empty inputs, causing it to try to read from an invalid memory location.

TensorFlow, an open source platform for machine learning, has a vulnerability where an attacker can cause an integer division by zero (a crash caused by dividing by zero) in the `tf.raw_ops.QuantizedBiasAdd` function. The bug occurs because the code divides by the number of elements in an input without first checking that this number is not zero.

TensorFlow, a machine learning platform, has a vulnerability where an attacker can cause a denial of service (making the system crash or stop responding) by triggering a failed safety check when converting sparse tensors (data structures with mostly empty values) to CSR sparse matrices. The bug happens because the code tries to access memory locations that are outside the bounds of allocated space, which can corrupt data.

TensorFlow has a vulnerability where an attacker can crash the system (a denial of service, or DoS attack) by sending specially crafted data to a specific function called `tf.raw_ops.QuantizeAndDequantizeV4Grad`. The bug happens because the function doesn't check that its input data (called tensors, which are multi-dimensional arrays) has the correct structure, causing the program to fail when it tries to process them.

TensorFlow, an open-source machine learning platform, has a vulnerability in its CTCGreedyDecoder function that allows attackers to crash the program through a denial of service attack (an attack that makes a service unavailable). The problem occurs because the code uses a CHECK statement that aborts the program instead of handling invalid input properly.

TensorFlow, a machine learning platform, has a vulnerability where attackers can cause a heap buffer overflow (a memory safety error where data is written beyond allocated memory) by sending specially crafted inputs to the `tf.raw_ops.StringNGrams` function. The problem occurs because the code doesn't properly handle edge cases where input splitting results in only padding elements, potentially causing the program to read from invalid memory locations.