In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
Inthe Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
Inthe Linux kernel, thefollowing vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It couldresult in an out-of-bounds access when the time iszero.Here are more details:1. When the gts->itime_table[i].time_us is zero,e.g., the timesequenceis `3, 0, 1`,the inner for-loop will notterminate and doout-of-bound writes. This is because once`times[j] >new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1`position, whichmakes the if-condition always hold.Meanwhile, idx will be added one, making theloop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us iszero, the elementswill justbe copied without beingsorted asdescribed in the comment"Sort times from alltables to one and remove duplicates".For more details, please referto<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
IntheLinuxkernel, the followingvulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result inan out-of-bounds access when the time is zero.Hereare more details:1. When the gts->itime_table[i].time_us is zero, e.g., thetimesequence is `3, 0,1`, the innerfor-loop will not terminateand doout-of-bound writes. This is because once `times[j]> new`, thevalue`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position,which makes theif-condition always hold.Meanwhile, idx will be added one, making the loop keeprunning withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copiedwithout being sorted asdescribedin the comment"Sort times from all tables toone and remove duplicates".For more details, please refer to<ahref=https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linuxkernel, the following vulnerability has been resolved:iio:Fix thesorting functionality in iio_gts_build_avail_time_tableThesorting in iio_gts_build_avail_time_table is notworking as intended.It could result in an out-of-bounds access when thetime is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0,1`, the inner for-loop will not terminate and doout-of-boundwrites.This isbecause once `times[j] > new`, the value`new`will be added in thecurrent positionand the `times[j]` willbemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idxwill be added one, making the loop keeprunning withouttermination and out-of-bound write.2.If none of the gts->itime_table[i].time_us is zero, the elementswilljust be copiedwithout being sorted as described in the comment"Sort times from all tables toone and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
IntheLinux kernel,the following vulnerability has been resolved:iio: Fix thesortingfunctionality in iio_gts_build_avail_time_tableThe sortingin iio_gts_build_avail_time_table is not workingas intended.It could result in an out-of-bounds access when the time iszero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, theinner for-loop will not terminate and doout-of-bound writes.This isbecauseonce `times[j] > new`, the value`new` will beadded in the currentposition and the`times[j]` will bemovedto `j+1` position, which makes the if-condition always hold.Meanwhile, idx will beadded one, making the loop keep runningwithouttermination and out-of-bound write.2. If noneof the gts->itime_table[i].time_us is zero, the elementswill just becopied withoutbeing sorted as described in the comment"Sort times from all tables to one andremove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to thisissue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In theLinux kernel,thefollowing vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not workingasintended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0,1`, the innerfor-loop will not terminate anddoout-of-bound writes. This isbecause once `times[j] > new`, thevalue`new` will be added in the currentposition and the `times[j]` will bemoved to`j+1` position, which makes the if-condition alwayshold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us iszero, theelementswill just becopied without being sortedas described inthecomment"Sort times from all tables to one and remove duplicates".For more details, please refer to<ahref= https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com >https://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com</a>.The Linux kernel CVE team has assigned CVE-2024-43825 to this issue.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
IntheLinuxkernel,thefollowingvulnerabilityhasbeen resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could resultinan out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop willnot terminateand doout-of-bound writes. Thisis because once `times[j] >new`, the value`new` will be added inthe current position and the `times[j]`will bemoved to `j+1` position, which makesthe if-condition always hold.Meanwhile, idx will beadded one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill justbe copiedwithout being sortedas described in the commentSort times fromalltables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
| linux | | https://git.kernel.org/linus/5acc3f971a01be48d5ff4252d8f9cdb87998cdfb | https://git.kernel.org/linus/38416c28e16890b52fdd5eb73479299ec3f062f3 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, theelementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
Inthe Linux kernel, thefollowing vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It couldresult in an out-of-bounds access when the time iszero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-boundwrites. This isbecause once `times[j] > new`, thevalue`new` willbe added in the current position and the`times[j]`will bemoved to`j+1`position,which makes the if-condition alwayshold.Meanwhile, idx will be addedone,making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in thecomment Sort timesfrom all tables to one and remove duplicates.For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
In the Linux kernel, the following vulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result in an out-of-bounds access when the time is zero.Here are more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. This is because once `times[j] > new`, the value`new` will be added in the current position and the `times[j]` will bemoved to `j+1` position, which makes the if-condition always hold.Meanwhile, idx will be added one, making the loop keep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort times from all tables to one and remove duplicates .For more details, please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
IntheLinuxkernel, the followingvulnerability has been resolved:iio: Fix the sorting functionality in iio_gts_build_avail_time_tableThe sorting in iio_gts_build_avail_time_table is not working as intended.It could result inan out-of-bounds access when the time is zero.Hereare more details:1. When the gts->itime_table[i].time_us is zero, e.g., the timesequence is `3, 0, 1`, the inner for-loop will not terminate and doout-of-bound writes. Thisis because once`times[j] > new`, the value`new` willbe added in thecurrent position and the `times[j]` willbemoved to`j+1` position,whichmakes theif-condition always hold.Meanwhile,idx will be added one, making theloopkeep running withouttermination and out-of-bound write.2. If none of the gts->itime_table[i].time_us is zero, the elementswill just be copied without being sorted as described in the comment Sort timesfrom all tables toone and remove duplicates .For more details,please refer tohttps://lore.kernel.org/all/6dd0d822-046c-4dd2-9532-79d7ab96ec05@gmail.com.
