CVE-2026-46121
Beschrijving NL
In de Linux kernel is de volgende kwetsbaarheid verholpen:
mm/damon/sysfs-schemes: bescherm memcg_path kfree() met damon_sysfs_lock
Patch-serie "mm/damon/sysfs-schemes: fix use-after-free for [memcg_]path". Leest van 'memcg_path' en 'path' bestanden in DAMON sysfs interface kan racen
met hun schrijfsels, resulteert in gebruik-na-vrij. Los deze op. Deze patch (van 2):
damon_sysfs_scheme_filter->mmecg_path kan worden gelezen en geschreven door gebruikers,
via DAMON sysfs memcg_path bestand. Het kan ook indirect worden gelezen, voor de
parameters {on,off}line committen aan DAMON. De leest voor parameters
committen worden beschermd door damon_sysfs_lock om sysfs-bestanden te vermijden
wordt vernietigd terwijl een van de parameters wordt gelezen. Maar de
door de gebruiker gestuurde directe lees- en schrijfbewerkingen zijn niet beveiligd door een vergrendeling, terwijl
het schrijven is de toewijzing van de memcg_path-pointing buffer aan het dealloceren. Dientengevolge,
de lezers de reeds vrijgekomen buffer konden lezen (user-after-free). Opmerking
dat de user-reads niet racen wanneer hetzelfde geopende bestand wordt gebruikt door de
schrijver, vanwege de open bestandsvergrendeling van kernfs. Desalniettemin, het doen van de read
en schrijft met afzonderlijke geopende bestanden zou gebruikelijk zijn. Repareer het door te beschermen
zowel de user-direct leest als schrijft met damon_sysfs_lock.
Origineel (Engels) tonen
In the Linux kernel, the following vulnerability has been resolved:
mm/damon/sysfs-schemes: protect memcg_path kfree() with damon_sysfs_lock
Patch series "mm/damon/sysfs-schemes: fix use-after-free for [memcg_]path".
Reads of 'memcg_path' and 'path' files in DAMON sysfs interface could race
with their writes, results in use-after-free. Fix those.
This patch (of 2):
damon_sysfs_scheme_filter->mmecg_path can be read and written by users,
via DAMON sysfs memcg_path file. It can also be indirectly read, for the
parameters {on,off}line committing to DAMON. The reads for parameters
committing are protected by damon_sysfs_lock to avoid the sysfs files
being destroyed while any of the parameters are being read. But the
user-driven direct reads and writes are not protected by any lock, while
the write is deallocating the memcg_path-pointing buffer. As a result,
the readers could read the already freed buffer (user-after-free). Note
that the user-reads don't race when the same open file is used by the
writer, due to kernfs's open file locking. Nonetheless, doing the reads
and writes with separate open files would be common. Fix it by protecting
both the user-direct reads and writes with damon_sysfs_lock.