{"id":38158,"date":"2026-05-08T13:54:15","date_gmt":"2026-05-08T11:54:15","guid":{"rendered":"https:\/\/enginsight.com\/?p=38158"},"modified":"2026-05-08T13:54:16","modified_gmt":"2026-05-08T11:54:16","slug":"copyfail-cve-2026-31431-funktionsweise-erkennung-und-schutzmassnahmen-fuer-linux-systeme","status":"publish","type":"post","link":"https:\/\/enginsight.com\/de\/blog\/copyfail-cve-2026-31431-funktionsweise-erkennung-und-schutzmassnahmen-fuer-linux-systeme\/","title":{"rendered":"CopyFail (CVE-2026-31431): Funktionsweise, Erkennung und Schutzma\u00dfnahmen f\u00fcr Linux-Systeme"},"content":{"rendered":"

Am 29. April 2026 wurde die Schwachstelle CVE-2026-31431 mit dem Namen „Copy Fail“ öffentlich bekannt gemacht<\/a>.<\/p>\n\n\n\n

Sie betrifft viele Linux-Distributionen mit betroffenen Kernel-Versionen. Der Angriff nutzt hierbei drei Kernel-Komponenten.<\/p>\n\n\n\n

Wie funktioniert der Angriff<\/h2>\n\n\n\n

AF_ALG<\/code> ist eine Socket-basierte Kernel-Schnittstelle für Kryptografie, über die unprivilegierte Nutzer kryptografische Operationen wie Verschlüsselung und Hashing ausführen können, ohne Root-Rechte zu benötigen. Über diese Schnittstelle ist unter anderem auch das Template authencesn<\/code> erreichbar, das mehrere kryptografische Verfahren kombiniert. In diesem befindet sich der Logikfehler. Mithilfe von splice()<\/code> können Daten aus einer Datei ohne Kopieren direkt aus dem Page Cache in den Krypto-Socket übergeben werden, wobei lediglich Referenzen auf die bestehenden Speicherseiten verwendet werden. Durch eine Kernel-Optimierung zeigen Eingabe- und Ausgabepuffer dabei auf dieselben Speicherseiten. Wenn authencesn<\/code> diese Daten verarbeitet, schreibt es aufgrund eines Fehlers vier Bytes außerhalb des vorgesehenen Puffers und damit direkt in den ursprünglichen Speicherbereich zurück, aus dem die Eingabe stammt.<\/p>\n\n\n\n

Durch den Fehler wird einem unprivilegierten lokalen Nutzer ermöglicht, einen eingeschränkt kontrollierbaren 4-Byte-Schreibzugriff in den Page Cache von Dateien auszulösen, für die der Angreifer Leseberechtigungen besitzt. Der Page Cache ist dabei der Puffer, den der Linux-Kernel zwischen Arbeitsspeicher und Datenträger nutzt. Liest ein Prozess eine Datei, wird deren Inhalt einmalig in den RAM geladen und dort zwischengespeichert. Genau diese im Speicher liegende Kopie wird durch den Angriff verändert, nicht jedoch die Datei auf der Festplatte selbst. Besonders kritisch ist, dass diese Änderungen nicht als „dirty“ markiert werden und somit weder vom Writeback-Mechanismus noch von klassischen Integritätsprüfungen erkannt werden. Da der Page Cache systemweit und auch über Container-Grenzen hinweg geteilt wird, können die manipulierten Daten von anderen Prozessen übernommen werden.<\/p>\n\n\n\n

Ein lediglich 732 Byte großes Python-Skript, das nur Standardbibliotheken nutzt, reicht aus, um diesen Mechanismus auszunutzen und auf praktisch allen gängigen Linux-Distributionen Root-Rechte zu erlangen.<\/p>\n\n\n\n

Warum ist die CVE so gefährlich?<\/strong><\/h2>\n\n\n\n

Der Exploit muss nicht als schadhaftes Programm in Erscheinung treten. Jede Anwendung, jedes automatisierte Script, jedes kompromittierte Paket-Update kann ihn heimlich mittransportieren. Der Nutzer sieht dabei eine normal laufende Software. Im Hintergrund werden Root-Rechte erlangt, persistente Backdoors eingerichtet, Zugangsdaten ausgelesen oder andere Systeme im Netzwerk angegriffen.<\/p>\n\n\n\n

Die Exploit Kette erklärt:<\/h2>\n\n\n\n
    \n
  1. AF_ALG-Socket einrichten<\/strong>
    Der Angreifer öffnet einen AF_ALG<\/code>-Socket und bindet ihn an das Template authencesn(hmac(sha256),cbc(aes))<\/code>. Das ist ein normaler, unprivilegierter Syscall. Der Kernel stellt diese Schnittstelle bereit, damit Userspace-Programme die Krypto-Hardware nutzen können (z. B. für IPsec). Danach wird ein „Request Socket“ per accept()<\/code> erzeugt, über den die eigentlichen Krypto-Operationen laufen.

    authencesn(hmac(sha256),cbc(aes))<\/code> ist eine Kernel-interne Notation ür ein zusammengesetztes kryptografisches Template. Es beschreibt, welche zwei Verfahren authencesn<\/code> kombiniert und wie.
    <\/li>\n\n\n\n
  2. Zieldatei in den Socket einspeisen<\/strong>
    Normalerweise würde man mit write()<\/code>in einen Socket schreiben, da die Bytes dabei kopiert werden.splice()<\/code> übergibt hingegen einen Zeiger auf die bereits im Speicher gecachten Seiten der Datei (Page Cache), ohne sie zu kopieren. Der Angreifer öffnet \/usr\/bin\/su<\/code> (lesbar für jeden) und spleißt einen bestimmten Bereich dieser Datei in eine Pipe und von dort in den AF_ALG-Socket.
    <\/li>\n\n\n\n
  3. Den 4-Byte-Schreibvorgang platzieren<\/strong>
    Vor dem eigentlichen Krypto-Aufruf schickt der Angreifer per sendmsg()<\/code> die AAD (Associated Authenticated Data) an den Socket. In den Bytes 4–7 der AAD stecken die 4 Bytes, die später in die Zieldatei geschrieben werden sollen<\/strong>. Beispielsweise der Beginn eines Shellcode-Opcodes.

    Im nächsten Schritt wird recvmsg()<\/code> aufgerufen, was die AEAD-Entschlüsselung auslöst. Im Inneren von authencesn<\/code> läuft nun folgendes ab:

    Der Algorithmus liest bestimmte Bytes (ESN) aus den Zusatzdaten (AAD). Anschließend werden 4 dieser Bytes, die von einem Angreifer kontrolliert werden können, an eine bestimmte Speicherstelle geschrieben. Aufgrund einer Optimierung im Kernel seit 2017 zeigt diese Speicherstelle jedoch nicht mehr auf einen sicheren Puffer, sondern auf eine im Speicher befindliche Datei, zum Beispiel \/usr\/bin\/su<\/code> im sogenannten Page Cache. Dadurch kann ein Angreifer gezielt 4 Bytes in den Kernel-Speicher schreiben. Zwar erkennt das System danach, dass die Nachricht ungültig ist, weil die HMAC-Prüfung fehlschlägt, und gibt einen Fehler zurück. Allerdings ist die Schreiboperation zu diesem Zeitpunkt bereits erfolgt und wird nicht rückgängig gemacht. Dadurch entsteht die Möglichkeit, trotz fehlgeschlagener Integritätsprüfung Daten im Speicher zu verändern.
    <\/li>\n\n\n\n
  4. Ausführung – execve als Zünder<\/strong>
    Wenn alle Chunks geschrieben sind, ruft der Angreifer execve("\/usr\/bin\/su")<\/code> auf.Der Kernel sucht nun die Datei im Page Cache und findet sie dort sofort, denn die Seiten sind bereits geladen. Er lädt den (im Page Cache korrumpierten) Code und führt ihn aus. Da su<\/code> das setuid-Bit<\/strong> gesetzt hat, wechselt der Kernel beim Start automatisch auf UID 0 (root), unabhängig davon, wer die Datei aufruft.Der eingebettete Shellcode läuft jetzt mit Root-Rechten.<\/li>\n<\/ol>\n\n\n\n

    Nachstellung Exploit und Analyse im SIEM<\/h2>\n\n\n\n

    Ein Exploit wurde unter diesem Link<\/a> veröffentlicht und getestet. Dabei manipuliert das Pytho Skript den Kernel_page-Cache der Ziel Binärdatei (\/usr\/bin\/su<\/code> oder ein anderes setuid<\/code>-Binary) direkt im Speicher. Da setuid<\/code>-Binärdateien mit root-Rechten ausgeführt werden, reicht es, deren Code im Cache zu überschreiben. Der nächste Aufruf von su<\/code> führt dann den manipulierten Code als uid=0<\/code> (root) aus.<\/p>\n\n\n\n

    \"\"<\/figure>\n\n\n\n

    Über Sysmon ist leider nur erkennbar, dass ein privilegierter Nutzer (test<\/code>) eine Shell startet, und diese Shell läuft als root <\/strong>läuft. Dies führt leider oft zu false positves, da auch legitime Tools wie Ansible sehr viele kurzlebige Shells als root spwant. Aus diesem Grund ist das Log kein Indikator für einen Exploit.<\/p>\n\n\n\n

    \"\"<\/figure>\n\n\n\n

    Eine Alternative zur Erkennung des Exploits ist auditd<\/code>. Dieses überwacht Sicherheitsereignisse auf Linux, unter anderem SOCKET-Events und Funtkionsaufrufe.<\/p>\n\n\n\n

    Dafür benötigt es Regeln zu Überwachung, die wie folgt aussehen könnten:<\/p>\n\n\n\n

    \n
    Code<\/div>\n
    # Alle AF_ALG Socket-Events<\/span>\nausearch –<\/span>k af_alg_socket\n# splice()-Aufrufe der letzten Stunde<\/span>\nausearch –<\/span>k splice_call —<\/span>start recent\n# Lesezugriffe auf \/usr\/bin\/su von Nicht-Root<\/span>\nausearch –<\/span>k setuid_read |<\/span> grep –<\/span>v ‚uid=0‘<\/span>\n# UID-Sprünge auf root<\/span>\nausearch –<\/span>k uid_to_root\n# Alle Events einer verdächtigen PID zusammen<\/span>\nausearch —<\/span>pid 4321<\/span><\/div>\n<\/div>\n\n\n\n

    Dadurch ist es möglich, Sessions zu identifizeren in denen af_alg_socket<\/code> + splice<\/code> + setuid_exec<\/code> zusammen auftauchen:<\/p>\n\n\n\n

    \"\"<\/figure>\n\n\n\n

    Das Log sagt folgendes aus.<\/p>\n\n\n\n

    \n
    Code<\/div>\n
    syscall<\/span>=<\/span>59<\/span> → execve() – eine Datei wird ausgeführt<\/span>\nexe<\/span>=<\/span>\/usr\/bin\/su<\/span> → die Zieldatei<\/span>\nuid<\/span>=<\/span>1000<\/span> → aufgerufen von einem normalen Nutzer<\/span>\neuid<\/span>=<\/span>0<\/span> → aber läuft als root (effective UID = 0)<\/span>\nkey<\/span>=<\/span>setuid_exec<\/span> → die Audit-Regel hat angeschlagen<\/span>\nses<\/span>=<\/span>3<\/span> → Session 3 – verdächtige Session<\/span>\nsuccess<\/span>=<\/span>yes<\/span> → Ausführung war erfolgreich<\/span><\/div>\n<\/div>\n\n\n\n

    Im weiteren Verlauf kann anhand der Session 3 die folgenden Aufrufe gesucht werden, um den Exploit zu bestätigen.<\/p>\n\n\n\n

    AF_ALG Socket<\/td>af_alg_socket<\/code><\/td><\/tr>
    splice()-Aufrufe<\/td>splice_call<\/code><\/td><\/tr>
    Lesezugriff auf su<\/td>setuid_read<\/code><\/td><\/tr>
    dieser Event<\/strong><\/td>setuid_exec<\/code><\/td><\/tr>
    UID-Wechsel<\/td>uid_to_root<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

    Handlungsempfehlungen:<\/h2>\n\n\n\n

    1.AF_ALG<\/code>-Socket Erstellung blockieren:<\/p>\n\n\n\n

    Das Kernel-Modul algif_aead<\/code> sollte deaktiviert bzw. nicht geladen werden, sofern es im System nicht zwingend benötigt wird. Dieses Modul stellt die Schnittstelle bereit, über die AEAD-Algorithmen via AF_ALG<\/code>-Sockets aus dem Userspace angesprochen werden können. Wird das Modul nicht geladen, ist es für Nutzer nicht möglich, entsprechende Sockets zu öffnen. Dadurch wird der gesamte beschriebene Angriffsweg effektiv unterbunden, da bereits der erste Schritt, das Binden des Sockets, fehlschlägt. Mehr<\/a> dazu.<\/p>\n\n\n\n

    \n
    Code<\/div>\n
    echo<\/span> „install algif_aead \/bin\/false“<\/span> ><\/span> \/etc\/modprobe.d\/disable-algif-aead.conf\nrmmod<\/span> algif_aead 2<\/span>><\/span>\/dev\/null<\/div>\n<\/div>\n\n\n\n

    2. Bei manchen Distributionen ist algif_aead<\/code> kein Modul, sondern fest im Kernel einkompiliert (Beispiel Red Hat). Die Lösung dafür ist das Blockieren des Aufrufs der Kernel-Funktion. Dafür muss man beim Boot dem Kernel folgenden Parameter übergeben: initcall_blacklist=algif_aead_init<\/code>. Mehr<\/a> dazu.<\/p>\n\n\n\n

    3. Kernel Paket der genutzten Distribution patchen<\/p>\n\n\n\n

    <\/p>\n","protected":false},"excerpt":{"rendered":"

    Am 29. April 2026 wurde die Schwachstelle CVE-2026-31431 mit dem Namen „Copy Fail“ öffentlich bekannt gemacht. Sie betrifft viele Linux-Distributionen mit betroffenen Kernel-Versionen. Der Angriff nutzt hierbei drei Kernel-Komponenten. Wie funktioniert der Angriff AF_ALG ist eine Socket-basierte Kernel-Schnittstelle für Kryptografie, über die unprivilegierte Nutzer kryptografische Operationen wie Verschlüsselung und Hashing ausführen können, ohne Root-Rechte zu […]<\/p>\n","protected":false},"author":36,"featured_media":38162,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"content-type":"","_eb_attr":"","footnotes":""},"categories":[334],"tags":[],"class_list":["post-38158","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-schwachstellen"],"_links":{"self":[{"href":"https:\/\/enginsight.com\/de\/wp-json\/wp\/v2\/posts\/38158","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/enginsight.com\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/enginsight.com\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/enginsight.com\/de\/wp-json\/wp\/v2\/users\/36"}],"replies":[{"embeddable":true,"href":"https:\/\/enginsight.com\/de\/wp-json\/wp\/v2\/comments?post=38158"}],"version-history":[{"count":1,"href":"https:\/\/enginsight.com\/de\/wp-json\/wp\/v2\/posts\/38158\/revisions"}],"predecessor-version":[{"id":38163,"href":"https:\/\/enginsight.com\/de\/wp-json\/wp\/v2\/posts\/38158\/revisions\/38163"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/enginsight.com\/de\/wp-json\/wp\/v2\/media\/38162"}],"wp:attachment":[{"href":"https:\/\/enginsight.com\/de\/wp-json\/wp\/v2\/media?parent=38158"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/enginsight.com\/de\/wp-json\/wp\/v2\/categories?post=38158"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/enginsight.com\/de\/wp-json\/wp\/v2\/tags?post=38158"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}