Wysoki Odebrany

CVE-2026-104795

opublikowano: 14.10.2026, 13:16

modyfikacja: 14.10.2026, 18:17

Ocena CVSS

8.8

Wysoki · v3.1

Oficjalne źródła

wektor: CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H

>_ Opis

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

Ekstraktor Insights-Runtime-Extractor działa jako uprzywilejowany zestaw DaemonSet („hostPID: true”)
który skanuje procesy kontenerowe pod kątem odcisków palców w czasie wykonywania. Podczas skanowania a
kontener, koordynator:

1. **fork()s** jest procesem potomnym
2. **setns()** do przestrzeni nazw PID i montowania kontenera docelowego
3. **fchdir()** powrót do osieroconego FD wskazującego na własny korzeń ekstraktora
system plików (gdzie `/crio.sock` jest zamontowany na HostPath)
4. Wywołuje **tylko `seteuid(target_uid)`** — zmiana efektywnego UID, ale wyjście
**rzeczywisty UID i zapisany zestaw UID na poziomie 0** i **zachowując dozwolone
zestaw możliwości**
5. Strażnik `check_no_privileged_perms()` sprawdza tylko zdolność Efektywną
set (więc przechodzi) i jest **całkowicie pomijany, gdy cel działa jako uid 0**
6. Odcisk palca `VersionExecutable` wywołuje `fpr_kind_executable` za pomocą
`process.command_line[0]` — argv[0] celu, czytany z
`/proc/<pid>/cmdline` i **w pełni kontrolowane przez obciążenie**
7. `fpr_kind_executable` wywołuje `exec.Command(plik wykonywalny, "--wersja").Output()`
— wykonanie **własnego pliku binarnego** obciążenia w jego wierzchołku
przestrzeni nazw, podczas gdy **ruid=0 w przestrzeni nazw użytkownika hosta**

Wykonywany proces może wywołać `setuid(0)` w celu przywrócenia pełnego katalogu głównego
`CAP_SYS_ADMIN` i dziedziczy osierocony cwd, który przekształca się w ekstraktor
system plików kontenera zawierający gniazdo CRI-O hosta.

## Kod, którego dotyczy problem

### 1. Niewystarczający spadek uprawnień (Rust — koordynator ekstraktora)

**Plik:** `extractor/src/insights_runtime_extractor.rs`

„rdza”.
// Linie 139-146 — upuszczenie tylko przez seteuid, ochrona pominięta w przypadku kontenerów root
Join_process_namespaces(proces.pid)?;
zmień_katalog(bieżący_katalog);
switch_user(*proces.uid)?;
if *proces.uid != 0 {
perms::check_no_privileged_perms()
.expect("Nie możesz mieć uprzywilejowanych uprawnień do uruchamiania odcisków palców");
}
odcisk palca::run_fingerprints(&config, out_dir, &process);
```

„rdza”.
// Linie 182-185 — zmieniony został tylko efektywny UID; ruid/suid pobyt 0
fn switch_user(uid: u32) -> Wynik<(), Błąd skanera> {
debug!("... Zostanie użytkownikiem: {uid}");
seteuid(uid.into()).map_err(|e|Błąd skanera::Errno(e))
}
```

### 2. Wykonanie niezaufanego pliku binarnego (Go — odcisk palca)

**Plik:** `fingerprints/pkg/utils/file.go`

idź
// Linie 75–80 — wykonuje ścieżkę pobraną dosłownie z argv[0] obciążenia
func GetExecutableVersionOutput(ciąg wykonywalny) (ciąg, błąd) {
out, err := exec.Command(plik wykonywalny, "--wersja").Output()
jeśli błąd!= zero {
zwróć „”, błąd
}
zwróć ciąg (wyjście), zero
}
```

### 3. Przekazano ścieżkę kontrolowaną przez obciążenie (Rust — wersja_wykonywalna)

**Plik:** `wersja_executable.rs`

„rdza”.
// Linie 29–34 — kontrolowana obciążeniem linia_poleceń[0] przekazywana do odcisku palca
zwróć trochę(vec![
plik wykonywalny fpr_kind_,
out_dir.to_string(),
String::from(&process.command_line[0]),
String::from(&wersja_executable.runtime_kind_name),
]);
```

## Wzór ataku

**Atakujący:** dowolny najemca, który może zaplanować pod (nieuprzywilejowany, dowolna przestrzeń nazw)
**Ofiara:** węzeł, na którym działa zestaw DaemonSet narzędzia do wyodrębniania wniosków
**Trigger:** Automatic — zestaw DaemonSet skanuje wszystkie procesy kontenerowe w węźle

**Sekwencja ataku:**

1. Osoba atakująca tworzy pod, którego nazwa procesu jest zgodna ze skonfigurowaną
wersjonowany wzorzec wykonywalny (`node`, `python`, `python3`, `MainThread`,
lub zawiera `Java`)
2. Główny plik binarny poda (w ścieżce odpowiadającej argv[0]) jest złośliwy
plik wykonywalny, który wywołuje `setuid(0)` w celu przywrócenia roota
3. Gdy operator Insights uruchomi skanowanie, zestaw DaemonSet rozwidla się i wchodzi do
przestrzeń nazw wierzchowca atakującego i wykonuje plik binarny atakującego z ruid=0
4. Kod atakującego odzyskuje pełny root z `CAP_SYS_ADMIN` w użytkowniku hosta
przestrzeń nazw
5. Odziedziczony cwd zawiera gniazdo CRI-O hosta → kompromis pełnego węzła

The insights-runtime-extractor runs as a privileged DaemonSet (`hostPID: true`)
that scans container processes for runtime fingerprinting. When scanning a
container, the coordinator:

1. **fork()s** a child process
2. **setns()** into the target container's PID and mount namespaces
3. **fchdir()** back to an orphaned FD pointing at the extractor's own root
filesystem (where `/crio.sock` is hostPath-mounted)
4. Calls **only `seteuid(target_uid)`** — changing the effective UID but leaving
the **real UID and saved-set-UID at 0** and **retaining the permitted
capability set**
5. The `check_no_privileged_perms()` guard inspects only the Effective capability
set (so it passes), and is **skipped entirely when the target runs as uid 0**
6. The `VersionExecutable` fingerprint invokes `fpr_kind_executable` with
`process.command_line[0]` — the target's argv[0], read from
`/proc/<pid>/cmdline` and **fully controlled by the workload**
7. `fpr_kind_executable` calls `exec.Command(executable, "--version").Output()`
— executing the **workload's own binary** inside the workload's mount
namespace while **ruid=0 in the host user namespace**

The executed process can call `setuid(0)` to restore full root with
`CAP_SYS_ADMIN`, and inherits the orphaned cwd which resolves into the extractor
container's filesystem containing the host CRI-O socket.

## Affected Code

### 1. Insufficient privilege drop (Rust — extractor coordinator)

**File:** `extractor/src/insights_runtime_extractor.rs`

```rust
// Lines 139-146 — seteuid-only drop, guard skipped for root containers
join_process_namespaces(process.pid)?;
change_dir(current_dir);
switch_user(*process.uid)?;
if *process.uid != 0 {
perms::check_no_privileged_perms()
.expect("Must not have privileged permissions to run fingerprints");
}
fingerprint::run_fingerprints(&config, out_dir, &process);
```

```rust
// Lines 182-185 — only effective UID changed; ruid/suid stay 0
fn switch_user(uid: u32) -> Result<(), ScannerError> {
debug!("... Becoming user: {uid}");
seteuid(uid.into()).map_err(|e| ScannerError::Errno(e))
}
```

### 2. Execution of untrusted binary (Go — fingerprint)

**File:** `fingerprints/pkg/utils/file.go`

```go
// Lines 75-80 — executes a path taken verbatim from workload's argv[0]
func GetExecutableVersionOutput(executable string) (string, error) {
out, err := exec.Command(executable, "--version").Output()
if err != nil {
return "", err
}
return string(out), nil
}
```

### 3. Workload-controlled path forwarded (Rust — version_executable)

**File:** `version_executable.rs`

```rust
// Lines 29-34 — workload-controlled command_line[0] forwarded to fingerprint
return Some(vec![
fpr_kind_executable,
out_dir.to_string(),
String::from(&process.command_line[0]),
String::from(&version_executable.runtime_kind_name),
]);
```

## Attack Pattern

**Attacker:** Any tenant able to schedule a pod (unprivileged, any namespace)
**Victim:** The node running the insights-runtime-extractor DaemonSet
**Trigger:** Automatic — the DaemonSet scans all container processes on the node

**Attack sequence:**

1. Attacker creates a pod whose process name matches a configured
versioned-executable pattern (`node`, `python`, `python3`, `MainThread`,
or contains `java`)
2. The pod's main binary (at the path matching argv[0]) is a malicious
executable that calls `setuid(0)` to restore root
3. When the insights operator triggers a scan, the DaemonSet forks, enters the
attacker's mount namespace, and executes the attacker's binary with ruid=0
4. The attacker's code regains full root with `CAP_SYS_ADMIN` in the host user
namespace
5. The inherited cwd contains the host CRI-O socket → full node compromise

>_ Słabości (CWE)

CWE-250

>_ 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