Linux: Use After Free
CVE-2023-53123 is a high-severity use after free vulnerability in Linux, with a CVSS 3.1 base score of 7.8 out of 10. It can be exploited with local access to the system by an attacker with a low-privileged account, without any action from a user. The record lists versions 437bb839e36cc9f35adc6d2a2bf113b7a0fc9985, a2410d0c3d2d714ed968a135dfcbed6aa3ff7027, b99ebf4b62774e690e73a551cf5fbf6f219bdd96 as the first without the flaw, so updating Linux to one of those releases or later removes the exposure. There is no confirmed exploitation so far. EPSS estimates a 0.19% chance of exploitation within 30 days, which is low compared with other CVEs.
High severity with no evidence of exploitation so far.
What to do
- Update Linux to 437bb839e36cc9f35adc6d2a2bf113b7a0fc9985 or a2410d0c3d2d714ed968a135dfcbed6aa3ff7027 or b99ebf4b62774e690e73a551cf5fbf6f219bdd96 or ab909509850b27fd39b8ba99e44cda39dbc3858c, whichever matches your release line, or a later version.
- Update Linux Kernel to 5.15.104 or 6.1.21 or 6.2.8, whichever matches your release line, or a later version.
Affected products and versions
| Vendor | Product | Affected versions | Fixed in |
|---|---|---|---|
| Linux | Linux | a50297cf8235b062bcdeaa8b1dad58e69d3e1b43 up to, but not including, 437bb839e36cc9f35adc6d2a2bf113b7a0fc9985; a50297cf8235b062bcdeaa8b1dad58e69d3e1b43 up to, but not including, a2410d0c3d2d714ed968a135dfcbed6aa3ff7027; a50297cf8235b062bcdeaa8b1dad58e69d3e1b43 up to, but not including, b99ebf4b62774e690e73a551cf5fbf6f219bdd96; a50297cf8235b062bcdeaa8b1dad58e69d3e1b43 up to, but not including, ab909509850b27fd39b8ba99e44cda39dbc3858c; 5.13 | 437bb839e36cc9f35adc6d2a2bf113b7a0fc9985, a2410d0c3d2d714ed968a135dfcbed6aa3ff7027, b99ebf4b62774e690e73a551cf5fbf6f219bdd96, ab909509850b27fd39b8ba99e44cda39dbc3858c |
| Linux | Linux Kernel | 5.13 up to, but not including, 5.15.104; 5.16 up to, but not including, 6.1.21; 6.2 up to, but not including, 6.2.8; 6.3 | 5.15.104, 6.1.21, 6.2.8 |
Version data comes from the organisation that assigned the CVE. Confirm against the vendor advisory before deciding you are unaffected.
How the severity score breaks down
- Attack vector
- LocalThe attacker needs local access or must trick a user into running something.
- Attack complexity
- LowNo special conditions are needed; the attack works reliably.
- Privileges required
- LowA basic user account is enough.
- User interaction
- NoneNo action by a victim is required.
- Scope
- UnchangedImpact stays within the vulnerable component.
- Confidentiality
- HighAll data handled by the component can be read.
- Integrity
- HighData or code can be modified at will.
- Availability
- HighThe component can be taken down completely.
Vector: CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H. Scored by NVD.
Official description
In the Linux kernel, the following vulnerability has been resolved: PCI: s390: Fix use-after-free of PCI resources with per-function hotplug On s390 PCI functions may be hotplugged individually even when they belong to a multi-function device. In particular on an SR-IOV device VFs may be removed and later re-added. In commit a50297cf8235 ("s390/pci: separate zbus creation from scanning") it was missed however that struct pci_bus and struct zpci_bus's resource list retained a reference to the PCI functions MMIO resources even though those resources are released and freed on hot-unplug. These stale resources may subsequently be claimed when the PCI function re-appears resulting in use-after-free. One idea of fixing this use-after-free in s390 specific code that was investigated was to simply keep resources around from the moment a PCI function first appeared until the whole virtual PCI bus created for a multi-function device disappears. The problem with this however is that due to the requirement of artificial MMIO addreesses (address cookies) extra logic is then needed to keep the address cookies compatible on re-plug. At the same time the MMIO resources semantically belong to the PCI function so tying their lifecycle to the function seems more logical. Instead a simpler approach is to remove the resources of an individually hot-unplugged PCI function from the PCI bus's resource list while keeping the resources of other PCI functions on the PCI bus untouched. This is done by introducing pci_bus_remove_resource() to remove an individual resource. Similarly the resource also needs to be removed from the struct zpci_bus's resource list. It turns out however, that there is really no need to add the MMIO resources to the struct zpci_bus's resource list at all and instead we can simply use the zpci_bar_struct's resource pointer directly.
Source: the CVE record as published by its numbering authority, via NVD and CVE.org.
The underlying weakness: Use After Free
The product reuses or references memory after it has been freed. At some point afterward, the memory may be allocated again and saved in another pointer, while the original pointer references a location somewhere within the new allocation. Any operations using the original pointer are no longer valid because the memory belongs to the code that operates on the new pointer.
How developers prevent this class of flaw
- Choose a language that provides automatic memory management.
- When freeing pointers, be sure to set them to NULL once they are freed. However, the utilization of multiple or complex data structures may lower the usefulness of this strategy.
Timeline
- CVE record published.
- CISA published its SSVC assessment (exploitation: none, automatable: no, technical impact: partial).
- Record last changed materially (score, affected products, status or references).
References
Patches and release notes
Recent Use After Free vulnerabilities
- 7.8 High severity
- 7.8 High severity
- 7.8 High severity
- 7.8 High severity
- 7.8 High severity
- 7.8 High severity
Spotted an error? Tell us.