Odebrany

CVE-2026-98981

opublikowano: 23.10.2026, 15:17

modyfikacja: 23.10.2026, 15:17

Ocena CVSS

n/a

Brak oceny

Oficjalne źródła

>_ Opis

Tłumaczenie automatyczne – może zawierać nieścisłości.

W jądrze Linuksa usunięto następującą lukę:

namespace: odblokuj dentry przed odłączeniem od niego wierzchowców

unlink(), rmdir() i rename() usuwają wpis z systemu plików,
wywołaj detach_mounts() na wpisie z zablokowanym i-węzłem, a następnie wywołaj
d_delete() po odblokowaniu i-węzła.

Rzecz w tym, że pomiędzy detach_mounts() i d_delete() dentry jest
nadal zaszyfrowany i pozytywny. Ale po odłączeniu() nic nie obejmuje
już dentysta. Wyszukiwanie, które znajdzie ten dentry w puszce dcache
odkryj to, co skrywały wierzchowce.

Stanowi to problem podczas odłączania plików lub katalogów, które są
punkty montowania w innych przestrzeniach nazw montowania. Każdy, kto miał podstawy
objęty wpis może ścigać się z wywołaniem detach_mount() do momentu uruchomienia d_delete().

Okno wyścigu nie jest wcale takie małe. Obejmuje namespace_unlock()
z pełnym okresem karencji synchronizacji_rcu_expedited() i
inode_unlock() wpisu.

W moich eksperymentach trzech piechurów, którzy próbowali czytać na wierzchołku
plik w 11938 z 16140 odłączeń, które usunęły jego punkt montowania z pliku
powiąż montowanie systemu plików w ciągu minuty.

Ciekawostka, d_invalidate() ma ten sam problem z porządkowaniem, ale go rozumie
prawda. Najpierw usuwa zęby, a następnie odłącza mocowania.
Zróbmy to samo w __detach_mounts():

- Wyszukiwanie, które nie znalazło jeszcze dentry, pomija ją w dcache i
czeka na blokadę katalogu, którą osoba wywołująca przechowuje do momentu pojawienia się nazwy
zniknął na dobre.

- Wyszukiwanie bez blokady, które znalazło, już nie przeszło kontroli mount_lock
podczas gdy dentry nadal liczy się jako punkt montowania i sprawdzenie d_seq raz
tak się nie dzieje i próbuje ponownie.

To naprawia ścieżkę bez blokady. Musimy jeszcze ustalić liczbę referencji
wyszukaj w kolejnej łatce.

Więc d_drop() dentysta. Zęby pozostają pozytywne i trzymają się, lecz nie jest to możliwe
już nie znaleziono. Następnie kontynuuj odłączanie i rozłączanie.

Producent:

Odczyty zliczano za pomocą poniższego programu, trzech spacerowiczów przez 60 s
na maszynie wirtualnej z 4 procesorami. Okno wyścigu jest rozciągnięte przez łatkę debugującą
wklejony tutaj. fs.detach_race_walk_us śpi w funkcji lookup_fast().
znalazł ząb wierzchowca i zanim jego wierzchowce zostały przekroczone.
fs.detach_race_unlink_us śpi w vfs_unlink() pomiędzy detach_mounts()
i d_delete().

// Identyfikator licencji SPDX: GPL-2.0
/*
* unlink_covered: odłącz plik będący punktem montowania w odłączonej kopii
* jego wierzchowiec, względem wyszukiwań, które otwierają go przez tę kopię.
*
* A to tmpfs z plikiem f1 (zawartość SECRET_F) i zwykłym plikiem
* MARK_A. A' jest kopią open_tree(OPEN_TREE_CLONE) A z powiązaniem MARK_A
* na A'/f1, utrzymywany przez O_PATH fd w jego korzeniu, gdy drzewo fd jest
* zamknięte. Walkery otwierają f1 przez ten fd, podczas gdy kierowca odłącza A/f1,
* gdzie nic nie jest na nim zamontowane. Pieszo może przeczytać MARK_A lub otrzymać ENOENT.
* Czytanie SECRET_F jest strzałem w dziesiątkę: nazwa została znaleziona po odkryciu wierzchowca
* zniknęło. Spacery bez zamków używają openat2 (RESOLVE_CACHED).
*
* użycie: unlink_covered [-t sekund] [-w spacerowiczów]
*/
#ifndef _GNU_SOURCE
#zdefiniuj _GNU_SOURCE
#endif
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <stdatomic.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <linux/openat2.h>

#ifndef __NR_open_tree
#zdefiniuj __NR_open_tree 428
#endif
#ifndef __NR_move_mount
#zdefiniuj __NR_move_mount 429
#endif
#ifndef __NR_openat2
#zdefiniuj __NR_openat2 437
#endif
#ifndef OPEN_TREE_CLONE
#zdefiniuj OPEN_TREE_CLONE 1
#endif
#ifndef OPEN_TREE_CLOEXEC
#zdefiniuj OPEN_TREE_CLOEXEC O_CLOEXEC
#endif
#ifndef MOVE_MOUNT_F_EMPTY_PATH
#zdefiniuj MOVE_MOUNT_F_EMPTY_PATH 0x00000004
#endif

#zdefiniuj PRACĘ „/tmp/uc”
#define ADIR PRACA „/A”

statyczny int czas trwania = 60, nwalkers = 3;
statyczny atomic_int stop, write_waiting;
statyczny pthread_rwlock_t cur_lock = PTHREAD_RWLOCK_INITIALIZER;
statyczny int cur_fd = -1; /* pierwiastek A', -1 wh
---obcięty---

In the Linux kernel, the following vulnerability has been resolved:

namespace: unhash a dentry before detaching the mounts on it

unlink(), rmdir() and rename() remove the entry from the filesystem,
call detach_mounts() on the entry with the inode locked and then call
d_delete() once the inode is unlocked.

The thing is that between detach_mounts() and d_delete() the dentry is
still hashed and positive. But after detach_mounts() nothing covers the
dentry anymore. A lookup that finds this dentry in the dcache can
uncover what the mounts hid.

That's a problem when unlinking files or directories that are
mountpoints in other mount namespaces. Everybody who had the underlying
entry covered can race the detach_mount() call until d_delete() has run.

The race window isn't all that small. It encompasses namespace_unlock()
with a full synchronize_rcu_expedited() grace period and the
inode_unlock() of the entry.

In my experiments three walkers that kept trying read an overmounted
file in 11938 of the 16140 unlinks that removed its mountpoint from a
bind mount of the filesystem within a minute.

Fun fact, d_invalidate() has the same ordering problem but gets it
right. It unhashes the dentry first and detaches the mounts afterwards.
Let's do the same in __detach_mounts():

- A lookup that hasn't found the dentry yet misses it in the dcache and
waits for the directory lock that the caller holds until the name is
gone for good.

- A lockless lookup that found it already fails the mount_lock check
while the dentry still counts as a mountpoint and the d_seq check once
it doesn't, and retries.

This fixes the lockless path. We still need to fix the reference count
lookup in a follow-up patch.

So d_drop() the dentry. The dentry stays positive and held but can't be
found anymore. Then proceed with the detach and unlink.

Reproducer:

The reads were counted with the program below, three walkers for 60 s
in a VM with 4 CPUs. The race window is stretched with the debug patch
pasted here. fs.detach_race_walk_us sleeps in lookup_fast() once it
found a mountpoint dentry and before its mounts are crossed.
fs.detach_race_unlink_us sleeps in vfs_unlink() between detach_mounts()
and d_delete().

// SPDX-License-Identifier: GPL-2.0
/*
* unlink_covered: unlink a file that is a mountpoint in a detached copy of
* its mount, against lookups that open it through that copy.
*
* A is a tmpfs with the file f1 (content SECRET_F) and the plain file
* MARK_A. A' is an open_tree(OPEN_TREE_CLONE) copy of A with MARK_A bound
* on A'/f1, held through an O_PATH fd on its root once the tree fd is
* closed. Walkers open f1 through that fd while the driver unlinks A/f1,
* where nothing is mounted on it. A walker may read MARK_A or get ENOENT.
* A read of SECRET_F is a hit: the name was found after its mount was
* gone. The lockless walks use openat2(RESOLVE_CACHED).
*
* usage: unlink_covered [-t seconds] [-w walkers]
*/
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <stdatomic.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <linux/openat2.h>

#ifndef __NR_open_tree
#define __NR_open_tree 428
#endif
#ifndef __NR_move_mount
#define __NR_move_mount 429
#endif
#ifndef __NR_openat2
#define __NR_openat2 437
#endif
#ifndef OPEN_TREE_CLONE
#define OPEN_TREE_CLONE 1
#endif
#ifndef OPEN_TREE_CLOEXEC
#define OPEN_TREE_CLOEXEC O_CLOEXEC
#endif
#ifndef MOVE_MOUNT_F_EMPTY_PATH
#define MOVE_MOUNT_F_EMPTY_PATH 0x00000004
#endif

#define WORK "/tmp/uc"
#define ADIR WORK "/A"

static int duration = 60, nwalkers = 3;
static atomic_int stop, writer_waiting;
static pthread_rwlock_t cur_lock = PTHREAD_RWLOCK_INITIALIZER;
static int cur_fd = -1; /* the root of A', -1 wh
---truncated---

>_ Referencje

Dane podatności pochodzą z oficjalnych źródeł (CVE® List / NVD). Opisy po polsku są tłumaczone automatycznie i mogą zawierać nieścisłości – na stronie rekordu można wyświetlić wersję angielską.

This product uses the NVD API but is not endorsed or certified by the NVD.

CVE Usage: MITRE hereby grants you a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute Common Vulnerabilities and Exposures (CVE®). Any copy you make for such purposes is authorized provided that you reproduce MITRE's copyright designation and this license in any such copy. ALL DOCUMENTS AND THE INFORMATION CONTAINED THEREIN PROVIDED BY MITRE ARE PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND.

NVD Terms of Use / CVE® Terms of Use / nvd.nist.gov / cve.org

<< baza_cve