CyberSecBulletin
CVE-2023-52854NVD status: Analyzed

Linux: Use After Free

Published Updated By the CyberSecBulletin desk

CVE-2023-52854 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 41aad9d6953984d134fc50f631f24ef476875d4d, 0dd34a7ad395dbcf6ae60e48e9786050e25b9bc5, c7c26d0ef5d20f00dbb2ae3befcabbe0efa77275 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.24% chance of exploitation within 30 days, which is low compared with other CVEs.

Next patch cycle

High severity with no evidence of exploitation so far.

What to do

  1. Update Linux to 41aad9d6953984d134fc50f631f24ef476875d4d or 0dd34a7ad395dbcf6ae60e48e9786050e25b9bc5 or c7c26d0ef5d20f00dbb2ae3befcabbe0efa77275 or 1e901bcb8af19416b65f5063a4af7996e5a51d7f, whichever matches your release line, or a later version.
  2. Update Linux Kernel to 3.17 or 4.5 or 4.10 or 4.15, whichever matches your release line, or a later version.

Affected products and versions

VendorProductAffected versionsFixed in
LinuxLinux07928d9bfc81640bab36f5190e8725894d93b659 up to, but not including, 41aad9d6953984d134fc50f631f24ef476875d4d; 07928d9bfc81640bab36f5190e8725894d93b659 up to, but not including, 0dd34a7ad395dbcf6ae60e48e9786050e25b9bc5; 07928d9bfc81640bab36f5190e8725894d93b659 up to, but not including, c7c26d0ef5d20f00dbb2ae3befcabbe0efa77275; 07928d9bfc81640bab36f5190e8725894d93b659 up to, but not including, 1e901bcb8af19416b65f5063a4af7996e5a51d7f; 07928d9bfc81640bab36f5190e8725894d93b659 up to, but not including, 1734a79e951914f1db2c65e635012a35db1c674b; 07928d9bfc81640bab36f5190e8725894d93b659 up to, but not including, 7ddc21e317b360c3444de3023bcc83b85fabae2f; 13721e447acc2b82c19cf72e9e6c4291c77693ed; 7a2ccb65f90168edc2348495bb56093c466ffa39; and 13 more ranges41aad9d6953984d134fc50f631f24ef476875d4d, 0dd34a7ad395dbcf6ae60e48e9786050e25b9bc5, c7c26d0ef5d20f00dbb2ae3befcabbe0efa77275, 1e901bcb8af19416b65f5063a4af7996e5a51d7f, 1734a79e951914f1db2c65e635012a35db1c674b, 7ddc21e317b360c3444de3023bcc83b85fabae2f
LinuxLinux Kernel3.16.84 up to, but not including, 3.17; 4.4.215 up to, but not including, 4.5; 4.9.215 up to, but not including, 4.10; 4.14.172 up to, but not including, 4.15; 4.19.103 up to, but not including, 4.20; 5.4.19 up to, but not including, 5.5; 5.5.3 up to, but not including, 5.10.201; 5.11 up to, but not including, 5.15.139; and 3 more ranges3.17, 4.5, 4.10, 4.15, 4.20, 5.5

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: padata: Fix refcnt handling in padata_free_shell() In a high-load arm64 environment, the pcrypt_aead01 test in LTP can lead to system UAF (Use-After-Free) issues. Due to the lengthy analysis of the pcrypt_aead01 function call, I'll describe the problem scenario using a simplified model: Suppose there's a user of padata named `user_function` that adheres to the padata requirement of calling `padata_free_shell` after `serial()` has been invoked, as demonstrated in the following code: ```c struct request { struct padata_priv padata; struct completion *done; }; void parallel(struct padata_priv *padata) { do_something(); } void serial(struct padata_priv *padata) { struct request *request = container_of(padata, struct request, padata); complete(request->done); } void user_function() { DECLARE_COMPLETION(done) padata->parallel = parallel; padata->serial = serial; padata_do_parallel(); wait_for_completion(&done); padata_free_shell(); } ``` In the corresponding padata.c file, there's the following code: ```c static void padata_serial_worker(struct work_struct *serial_work) { ... cnt = 0; while (!list_empty(&local_list)) { ... padata->serial(padata); cnt++; } local_bh_enable(); if (refcount_sub_and_test(cnt, &pd->refcnt)) padata_free_pd(pd); } ``` Because of the high system load and the accumulation of unexecuted softirq at this moment, `local_bh_enable()` in padata takes longer to execute than usual. Subsequently, when accessing `pd->refcnt`, `pd` has already been released by `padata_free_shell()`, resulting in a UAF issue with `pd->refcnt`. The fix is straightforward: add `refcount_dec_and_test` before calling `padata_free_pd` in `padata_free_shell`.

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.

More Use After Free vulnerabilities (CWE-416)

Timeline

  1. CVE record published.
  2. CISA published its SSVC assessment (exploitation: none, automatable: no, technical impact: partial).
  3. Record last changed materially (score, affected products, status or references).

References

Recent Use After Free vulnerabilities

Spotted an error? Tell us.