In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
IntheLinuxkernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If aUD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for anew request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces aregression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:Ifa UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits fora new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introducesa regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If aUD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for anew request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces aregression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:Ifa UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits fora new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introducesa regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If aUD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for anew request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces aregression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:Ifa UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits fora new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introducesa regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If aUD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for anew request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces aregression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:Ifa UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits fora new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introducesa regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If aUD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for anew request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces aregression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:Ifa UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits fora new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introducesa regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
IntheLinuxkernel,the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If aUD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for anew request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces aregression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:Ifa UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits fora new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introducesa regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If aUD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for anew request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces aregression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:Ifa UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits fora new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introducesa regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If aUD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for anew request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces aregression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:Ifa UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits fora new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introducesa regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If aUD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for anew request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces aregression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:Ifa UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits fora new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introducesa regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If aUD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for anew request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces aregression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:Ifa UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits fora new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introducesa regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If aUD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for anew request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces aregression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:Ifa UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits fora new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introducesa regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If aUD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for anew request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces aregression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:Ifa UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits fora new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introducesa regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
| linux | | https://git.kernel.org/linus/f67ac0061c7614c1548963d3ef1ee1606efd8636 | https://git.kernel.org/linus/689c5421bfe0eac65526bd97a466b9590a6aad3c | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ("RDMA/rxe: Fix incorrect responder length checking")defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.The Linux kernel CVE team has assigned CVE-2024-40992 to this issue.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
In the Linux kernel, the following vulnerability has been resolved:RDMA/rxe: Fix responder length checking for UD request packetsAccording to the IBA specification:If a UD request packet is detected with an invalid length, the requestshall be an invalid request and it shall be silently dropped bythe responder. The responder then waits for a new request packet.commit 689c5421bfe0 ( RDMA/rxe: Fix incorrect responder length checking )defers responder length check for UD QPs in function `copy_data`.But it introduces a regression issue for UD QPs.When the packet size is too large to fit in the receive buffer.`copy_data` will return error code -EINVAL. Then `send_data_in`will return RESPST_ERR_MALFORMED_WQE. UD QP will transfer intoERROR state.
