dcheng69/cve-2022-0185-case-studyBildungsfallstudie und Exploit-Entwicklungsdurchgang für CVE-2022-0185, einen Heap-basierten Pufferüberlauf im Linux-Kernel, der eine lokale Privilegienausweitung ermöglicht. Enthält POC, QEMU-Debugging und Ubuntu-Exploit mit detaillierter technischer Analyse.
Diese Fallstudie ist das Ergebnis einer Aufgabe des Kurses ECE 9069: Einführung in das Hacking: https://whisperlab.org/introduction-to-hacking/
CVE-2022-0185 ist ein heap-basierter Pufferüberlauffehler, der in der Art und Weise gefunden wurde, wie die Funktion legacy_parse_param in der Funktionalität des Dateisystemkontexts des Linux-Kernels die Länge der übergebenen Parameter überprüft. Ein nicht privilegierter (falls nicht privilegierte Benutzernamensräume aktiviert sind, andernfalls benötigt es das CAP_SYS_ADMIN-Privileg im Namensraum) lokaler Benutzer, der ein Dateisystem öffnen kann, das die Filesystem-Context-API nicht unterstützt (und daher auf die Legacy-Behandlung zurückfällt), könnte diesen Fehler nutzen, um seine Privilegien auf dem System zu erweitern. [1]
Nachdem diese Schwachstelle gemeldet wurde, wurde ein Patch zur Behebung dieses Fehlers veröffentlicht:
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=722d94847de2
https://ubuntu.com/security/CVE-2022-0185#impact-score
Es gibt eine ausführliche Beschreibung vom Entdecker: https://www.hackthebox.com/blog/CVE-2022-0185:_A_case_study
In diesem Repository werde ich die grundlegenden Schritte und die damit verbundenen Hintergrundinformationen zur Reproduktion dieser Schwachstelle erklären. Falls etwas unklar ist, können Sie mir eine E-Mail an [email protected] senden. Ich beantworte die Frage gerne.
Die Schwachstelle CVE-2022-0185 wurde am 02.11.2022 mit einem CVSS 3.x-Basiswert von 8,4 (Hoch) veröffentlicht.[1] Diese Schwachstelle ist ein heap-basierter Pufferüberlauf, der durch einen vorzeichenlosen Integer-Unterlauf verursacht wird.
Die Schwachstelle wurde im Linux-Kernel v5.1 eingeführt und betrifft alle Linux-Distributionen mit Kernelversionen höher als 5.1. Beispielsweise war Ubuntu 20.04 LTS (focal) von diesem Fehler betroffen. Ein Patch wurde jedoch veröffentlicht und ist seit Version 5.4.0-96.109 verfügbar.[3]
Die Ausnutzung dieser Schwachstelle ermöglicht es einem nicht privilegierten lokalen Benutzer, seine Privilegien auf dem System zu erweitern und möglicherweise das gesamte System zu gefährden.[1] [2]
Hier ist eine detaillierte Analyse des CVSS-Scores: Basis-Score: 8,4, was auf ein erhebliches Sicherheitsrisiko hinweist, das sofortige Aufmerksamkeit erfordert. Auswirkungs-Score: 5,9, was auf einen erheblichen potenziellen Schaden hindeutet, falls die Schwachstelle ausgenutzt wird. Die hohen Werte für Vertraulichkeit, Integrität und Verfügbarkeit tragen zu diesem Score bei. Ausnutzbarkeits-Score: 2,5, was auf eine relativ hohe Ausnutzbarkeit hindeutet. Der lokale Angriffsvektor, die hohe Integrität und die hohe Verfügbarkeit tragen zu diesem Score bei.
Tabelle 1.1 und Tabelle 1.2 enthalten weitere Informationen zu diesen Scores und ihren Komponenten.
| CVSS v3.1 Schweregrad | Wert |
|---|---|
| Basis-Score | 8,4 HOCH |
| Auswirkungs-Score | 5,9 |
| Ausnutzbarkeits-Score | 2,5 |
Tabelle 1.1 CVSS-Schweregrad-Scores[1]
Tabelle 1.2 CVSS-Vektor[1]
Es gibt in modernen Computern zwei Integer-Typen: vorzeichenbehaftet und vorzeichenlos. Die Darstellung vorzeichenbehafteter Zahlen erfolgt üblicherweise durch eine Operation namens Zweierkomplement.[4] "Das Zweierkomplement verwendet das Binärbit mit dem größten Stellenwert als Vorzeichen, um anzuzeigen, ob die Binärzahl positiv oder negativ ist"[4]
Die Einführung des Zweierkomplements wandelt die Berechnung der Subtraktion in eine Addition um, was das Design und die Implementierung der CPU vereinfacht. Die Erzeugung des Zweierkomplements einer Ganzzahl umfasst drei Schritte:[4]
Abb. 2.1.1.1 zeigt den Konvertierungsprozess in einem Diagramm mit einem konkreten Beispiel der Konvertierung von "-6" in sein Zweierkomplement-Format.
Abb. 2.1.1.1 Zweierkomplement-Konvertierung
Abbildung 2.1.1.2 zeigt den Prozess der Addition des Zweierkomplements von '-6' zu '+6'. Dies demonstriert, wie die Verwendung des Zweierkomplements die Addition als Ersatz für die Subtraktion ermöglicht.
Abb. 2.1.1.2 Addition mittels Zweierkomplement
Aus Abschnitt 2.1.1 wissen wir bereits, was das Zweierkomplement ist. Betrachten wir nun das Szenario des vorzeichenlosen Integer-Unterlaufs in Computern. In modernen Computern wird bei der Verwendung vorzeichenloser Zahlen das höchstwertige Bit nicht als Vorzeichenbit behandelt, sondern ist Teil der vorzeichenlosen Zahl selbst. Diese Situation bedeutet, dass bei der Subtraktion mit vorzeichenlosen Zahlen Vorsicht geboten ist, da dies zu einem Zustand führen kann, der als vorzeichenloser Integer-Unterlauf bekannt ist.[5]
Abb. 2.1.2.1 veranschaulicht die Situation, in der bei einer 8-Bit vorzeichenlosen Zahl 6 von 5 subtrahiert wird. Das Endergebnis ist 255, da die vorzeichenlose Zahl sich umschlägt. Wenn dieser Unterlauf in einer Bedingungsanweisung auftritt, kann er die Funktionalität der Anweisung stören.
Abb. 2.1.2.1 Vorzeichenloser Integer-Unterlauf
Im Linux-Kernel ist der Slab-Allokator ein Speicherverwaltungsmechanismus, der zur effizienten Allokation und Freigabe kleiner Speicherblöcke verwendet wird. Er bietet Leistungsvorteile, indem er mehrere Caches von Slabs verwaltet, die jeweils Speicherblöcke mit fester Größe enthalten. Typischerweise allokiert kmalloc-32 32 Bytes Speicher (ein kmalloc-32-Slab), während kmalloc-4k 4096 Bytes Speicher allokiert (ein kmalloc-4k-Slab).[6]
Darüber hinaus erfolgt die Slab-Allokation im Linux-Kernel typischerweise durch die Allokation von Speicher aus einem zusammenhängenden Adressraum innerhalb des Heap-Speicherbereichs des Kernels. Dieser zusammenhängende Adressraum wird vom Kernel verwaltet und zur Allokation von Speicher für verschiedene Kernel-Objekte und Datenstrukturen verwendet. Abb. 2.2.1.1 zeigt das Layout der Slabs im Linux-Kernel-Speicher.
Abb. 2.2.1.1 Slab-Allokator in Linux [7] (Der Autor dieser Abbildung ist https://leviathan.vip/)
Wenn Sie den Prozess mit einem selbst kompilierten Linux-Kernel reproduzieren möchten, lesen Sie bitte die folgenden Markdown-Dateien, um die Hintergrundinformationen zu erhalten:
Hinweis:
Alle Markdown-Dateien sowie der Code und die Skripte befinden sich in verschiedenen Ordnern dieses Repositorys. Jeder Ordner enthält eine eigene Markdown-Datei. Lesen Sie diese, bevor Sie etwas ausprobieren!
In Abschnitt 2.1 haben wir erklärt, wie ein vorzeichenloser Unterlauf funktioniert. Nun werden wir die Kernelfunktion untersuchen, die diese Schwachstelle enthält.
Der Benutzer "clubby789" entdeckte eine Schwachstelle in der Kernelfunktion legacy_parse_param. Diese Funktion ist hauptsächlich für das Parsen von Parametern zuständig, die an den Kernel übergeben werden. In CVE-2022-0185 wurde sie aufgerufen, nachdem fsopen verwendet wurde, um einen Dateideskriptor zu öffnen, gefolgt von der Verwendung der Funktion fsconfig, um die Konfigurationsschlüssel-Wert-Paare an den Kernel zu übergeben. Eine vereinfachte Version von legacy_parse_param ist im folgenden Code dargestellt. [2]```c
static int legacy_parse_param(struct fs_context *fc, struct fs_parameter *param) {
struct legacy_fs_context *ctx = fc->fs_private; // [1]
unsigned int size = ctx->data_size; // [2]
size_t len = 0;
int ret;
[ ... ]
switch (param->type) {
case fs_value_is_string:
len = 1 + param->size; // [3]
case fs_value_is_flag:
len += strlen(param->key);
break;
default:
return invalf(fc, "VFS: Legacy: Parameter type for '%s' not supported", param->key);
}
if (len > PAGE_SIZE-2-size) return invalf(fc, "VFS: Legacy: Cumulative options too large"); // [4]
[ ... ]
if (!ctx->legacy_data) {
ctx->legacy_data = kmalloc(PAGE_SIZE, GFP_KERNEL); // [5]
if (!ctx->legacy_data) return -ENOMEM;
}
ctx->legacy_data[size++] = ','; // [6]
len = strlen(param->key);
memcpy(ctx->legacy_data + size, param->key, len);
size += len;
if (param->type == fs_value_is_string) {
ctx->legacy_data[size++] = '=';
memcpy(ctx->legacy_data + size, param->string, param->size);
size += param->size;
}
ctx->legacy_data[size] = '\0';
ctx->data_size = size;
ctx->param_type = LEGACY_FS_INDIVIDUAL_PARAMS;
return 0;
}
Aus dem obigen Codeausschnitt ist ersichtlich, dass die Zeilen [1] und [2] den Kontext des Codes festlegen, während Zeile [4] die Anweisung enthält, in der ein unsigned-Underflow auftritt. Zeile [5] kümmert sich um die Heap-Slab-Allokation, und die Zeilen [6] und [7] sind für das Befüllen der allokierten Slab mit Daten verantwortlich. Bemerkenswert ist, dass Zeile [6] ein Komma (',') als separates Trennzeichen hinzufügt und auch ein Gleichheitszeichen ('=') hinzugefügt wird, was zu zwei zusätzlichen Bytes über die tatsächliche Datengröße hinaus führt.
In Zeile [4] enthalten die Variablen innerhalb der if-Anweisung `PAGE_SIZE` (ein Makro, das auf 4096 gesetzt ist) und `size` (eine vorzeichenlose 64-Bit-Zahl). Wenn eine vorzeichenlose Zahl auf 4095 anwächst, tritt ein Underflow auf, wodurch die if-Anweisung immer zu `false` ausgewertet wird. Dies ermöglicht einen Out-of-Bounds-Schreibzugriff auf die benachbarte Slab. Der Underflow wird durch das Subtrahieren einer vorzeichenlosen Zahl verursacht, was 4096 - 4095 ergibt, was eine vorzeichenlose Zahl von 18446744073709551615 liefert.[2]
Das Ergebnis von `18446744073709551615` wird im folgenden Text erklärt:```c
if (len > PAGE_SIZE-2-size) return invalf(fc, "VFS: Legacy: Cumulative options too large");
Beachten Sie, dass hier PAGE_SIZE gleich 4096 Bytes ist und die 2 den Zeichen , und = entspricht, die hinzugefügt werden, um jedes Schlüssel-Wert-Paar zu trennen. Das Problem ist, dass size ein vorzeichenloser Wert ist. Wenn also size den Wert 4095 erreicht, ergibt die Anweisung PAGE_SIZE-2-size den vorzeichenbehafteten Wert: -1, jedoch für vorzeichenlose Werte: 18446744073709551615 aufgrund des Zweierkomplements, wie im folgenden Diagramm gezeigt! [3]
Daher wird die obige if-Anweisung immer falsch sein, was bedeutet, dass der Rest der Daten in den Heap jenseits des von uns allokierten Slabs kopiert wird!
Nachdem wir verstanden haben, wie dieser Unterlauf einer vorzeichenlosen Zahl auftreten kann, können wir einen Proof-of-Concept (POC) Code erstellen, um die Schwachstelle zu demonstrieren.
Benutzer „clubby789“ stellt uns einen detaillierten POC-Code zur Verfügung, der im folgenden Codeausschnitt gezeigt wird. Der Code ist prägnant; er öffnet zuerst einen Dateideskriptor namens ext4 und verwendet dann mehrmals fsconfig, um Daten in den Kernel einzuspeisen.
Zwei Dinge sind hier zu beachten:
In Abschnitt 3.1.1 haben wir erwähnt, dass 4095 Bytes Daten befüllt werden müssen, bevor der Schreibzugriff außerhalb der Grenzen beobachtet werden kann. Da jeder Zyklus nur 35 Bytes befüllt, müssen wir den Vorgang 117 Mal (4095 / 35) durchführen, bevor der Heap-Speicher beobachtet werden kann, um den Proof of Concept abzuschließen.
### 3.1.3 POC mit QEMU
In diesem Repository: GitHub - dcheng69/CVE-2022-0185-Case-Study haben wir ein Shell-Skript namens poc.sh bereitgestellt, um den Debugging-Prozess zu erleichtern. Bitte lesen Sie die Markdown-Datei im Poc-Ordner, bevor Sie mit dem Setup beginnen.
Da `legacy_parse_param` eine Kernel-Funktion ist, müssen Sie eine Kernel-Funktion debuggen. Dazu müssen Sie den Kernel-Quellcode kompilieren, um die erforderlichen Symbole und den Quellcode zu erhalten. Wir haben auch eine detaillierte Markdown-Datei bereitgestellt, die Sie durch den Prozess führt. Weitere Details finden Sie im Ordner `Compile_linux`.
In Abb. 3.1.3.1 haben wir gezeigt, dass es uns gelungen ist, nach dem Befüllen von 4095 Bytes Daten in den Kernel-Heap einen Schreibzugriff außerhalb der Grenzen auszulösen, indem wir einen Unsigned-Underflow ausgenutzt haben. Darüber hinaus haben wir insgesamt 4130 Bytes Daten in einen kmalloc-4k-Slab eingefüllt und dabei erfolgreich den benachbarten Slab korrumpiert. Obwohl der benachbarte Slab in diesem Beispiel keine Informationen enthält (alles Nullen), können wir unseren Code sorgfältig konstruieren, um diese Funktion zum Schreiben bösartiger Daten zu nutzen. Wir werden im Abschnitt 3.2 Exploit zeigen, wie dies erreicht werden kann.
**Abb. 3.1.3.1 POC mit QEMU**
Weitere Details finden Sie unter https://github.com/dcheng69/CVE-2022-0185-Case-Study/blob/main/Poc/poc.md im Ordner `Poc` dieses Repositorys!
## 3.2 Exploit
Nachdem wir diese Schwachstelle kennen, können wir damit einen Exploit erstellen. Details dazu sind im Ordner `exploit-ubuntu` sowie in dieser Markdown-Datei dokumentiert: https://github.com/dcheng69/CVE-2022-0185-Case-Study/blob/main/explot-ubuntu/exploit.md
Kurz gesagt, wir haben den Ubuntu-Quellcode kompiliert, eine DEB-Datei erhalten und diese dann auf einer virtuellen Maschine getestet, um eine bestimmte Kernel-Version zu erhalten. Dann haben wir den Offset des Exploit-Codes modifiziert, um mit den Informationen aus der `System.map`-Datei auf die Kernel-Version abzuzielen. Schließlich haben wir GRUB aktualisiert und neu gestartet, um den Exploit auszuführen!
### 3.2.1 Überblick über den Exploit
Der Benutzer 'clubby789' stellt uns einen detaillierten Exploit-Code zur Verfügung. Wir beginnen mit einem Überblick, gefolgt von Erklärungen mehrerer Schlüsselkonzepte anhand von Diagrammen. Abschließend präsentieren wir die Exploit-Ergebnisse mit Ubuntu auf einer virtuellen Maschine (VirtualBox).
Nachdem wir den Proof of Concept für diese Schwachstelle demonstriert haben, können wir nun zur Ausnutzung übergehen. In Abb. 3.2.1.1 ist ein Überblick über die Ausnutzung dieser Schwachstelle dargestellt:
- Der linke Abschnitt konzentriert sich auf das Ermitteln der Basisadresse des Linux-Kernels. Dies wird erreicht, indem ein Unsigned-Underflow ausgenutzt wird, um das `m_ts`-Feld der `msg_msg`-Struktur zu überschreiben, sodass wir außerhalb der Grenzen lesen und auf zuvor gesprühte Kernel-Strukturen zugreifen können.
- Der rechte Abschnitt zielt darauf ab, Root-Rechte zu erlangen. Dies wird erreicht, indem ein Unsigned-Underflow ausgenutzt wird, um den `next`-Zeiger der `msg_msg`-Struktur zu überschreiben und auf `modprobe_path` zu zeigen. Dann lösen wir einen Seitenfehler aus, der unseren konstruierten FUSE-Code aufruft und willkürliche Schreibvorgänge im Kernelspace ermöglicht.
**Abb. 3.2.1.1 Überblick über den Exploit**
### 3.2.2 Ermitteln der Basisadresse des Linux-Kernels
Wie bereits analysiert, werden wir in diesem Teil den Unsigned-Underflow ausnutzen, um das `m_ts`-Feld der `msg_msg`-Struktur zu überschreiben, was einen Lesezugriff außerhalb der Grenzen ermöglicht. Indem wir den Heap mit Strukturen besprühen, die Kernel-Zeiger enthalten, können wir hoffentlich einen Speicher-Leak erhalten.
Die Struktur `struct msg_msg` ist eine Datenstruktur im Linux-Kernel, die zur Implementierung von System-V-Nachrichtenwarteschlangen verwendet wird. In diesem Abschnitt konzentrieren wir uns auf die interne Struktur von `struct msg_msg` und die Logik der Funktionen zum Senden, Empfangen und Zuweisen von Nachrichten. Wie in Abb. 3.2.2.1 gezeigt, sind dies die Funktionen, die wir verstehen müssen.
Die Implementierung des Sendens von Nachrichten befindet sich in der Datei `msg.c`, die die maximale Länge einer Nachricht auf 8192 Bytes festlegt. In der Funktion `alloc_msg` werden Nachrichten basierend auf ihrer Länge in Segmente unterteilt. Wenn die Länge der Nachricht zusammen mit dem Nachrichten-Header eine Seite (4096 Bytes) überschreitet, wird die Nachricht in mehreren Segmenten gespeichert, die durch Zeiger miteinander verbunden sind.
**Abb. 3.2.2.1 `struct msg_msg` senden und empfangen**
In Abb. 3.2.2.2 sehen wir, dass `struct msg_msg` als Nachrichten-Header dient und 0x30 Bytes Speicher belegt. Falls Restdaten in der Nachricht vorhanden sind, werden diese in Nachrichtensegmenten gespeichert und an `struct msg_msgseg` angehängt. Wenn der Kernel also Nachrichten mit maximal 8192 Bytes zulässt, werden die Daten in maximal drei Nachrichtensegmenten gespeichert.
**Abb. 3.2.2.2 `struct msg_msg`**
In Abb. 3.2.2.3 veranschaulichen wir die Struktur von `struct msg_msg`. Aus dem Code wissen wir, dass das Feld `m_ts` dasjenige ist, das wir überschreiben müssen, um außerhalb der Grenzen zu lesen. (Die draw.io-Quelldatei finden Sie bei Bedarf im Ordner `res`!)
**Abb. 3.2.2.2 Struktur von `struct msg_msg`**
Nachdem wir die Struktur von `struct msg_msg` verstanden haben, müssen wir lernen, wie man einen Kernel-Leak erhält. Der Linux-Kernel verfügt über die Funktion Kernel Address Space Layout Randomization (KASLR), was bedeutet, dass der Kernel-Code an einer zufälligen Adresse geladen wird, die während der Boot-Phase festgelegt wird. Der Offset vom Startpunkt des Kernels zu einer beliebigen Funktionsadresse bleibt jedoch konstant, sodass wir bestimmte Operationen durchführen können, um den Heap mit Strukturen zu füllen, die bestimmte Kernel-Funktionen enthalten. Durch Verringern des Offsets können wir die Startadresse des Kernels finden.
Glücklicherweise können wir den Heap leicht mit `seq_operations`-Strukturen besprühen, indem wir `/proc/self/stat` öffnen. Diese befinden sich in kmalloc-32-Slabs. Die Definition von `seq_operations` ist in Abb. 3.2.2.3 gezeigt.
**Abb. 3.2.2.3 Strukturen für Kernel-Leak**
Schließlich ist der gesamte Prozess in Abb. 3.2.2.4 dargestellt. Wir beginnen damit, die `legacy_data` mit 4095 Bytes Daten zu füllen, um uns auf das Überschreiben vorzubereiten. Dann konstruieren wir Nachrichten mit `struct msg_msg`. Da Heap-Speicher kontinuierlich zugewiesen wird, werden die konstruierten Nachrichten wahrscheinlich an den benachbarten kmalloc-4k-Slab angrenzen. Wir überschreiben das `m_ts`-Feld, indem wir die Daten steuern, die wir in die `legacy_data` schreiben.
Als Nächstes besprühen wir den Heap mit mehreren kmalloc-32 `seq_operations`-Strukturen. Dann empfangen wir Daten aus der Nachrichtenwarteschlange, was einen Lesezugriff außerhalb der Grenzen auslöst. Durch Anpassen des Offsets von der Kernel-Funktion können wir die Basisadresse des Kernels ermitteln.
**Abb. 3.2.2.3 Überblick über Out-of-Bound Read**
### 3.2.3 Root-Rechte erlangen
Ähnlich wie in unserer früheren Analyse müssen wir in diesem Teil ein FUSE-Dateisystem einrichten, das es unserem Userspace-Code ermöglicht, Seitenfehler aus dem Kernelspace zu behandeln. Gleichzeitig überschreiben wir den `msg_msgseg *next`-Zeiger, um auf `modprobe_path` zu zeigen, was willkürliche Schreibvorgänge im Kernelspace ermöglicht.
Betrachten wir zunächst den FUSE-Aufrufstapel in Abb. 3.2.3.1. Im Allgemeinen ermöglicht FUSE die Implementierung eines Dateisystems im Userspace. Wenn eine neue Operation anfällt, ruft das System den von uns für FUSE definierten Code auf!
**Abb. 3.2.3.1 FUSE-Überblick**
Lassen Sie uns analysieren, wie FUSE verwendet werden kann, um willkürliche Schreibvorgänge im Kernelspace zu erreichen. Betrachten wir zunächst die Send-Nachricht-Operation für `struct msg_msg`. Diese Operation beinhaltet das Schreiben von Daten in den Kernelspace. Wenn wir die Nachricht so konstruieren, dass sie zwei Segmente hat, können wir den Zeiger überschreiben und in jede Kernel-Adresse schreiben. Dieses Konzept ist in Abb. 3.2.3.2 dargestellt.
Nachdem wir die Logik des Sendens von Nachrichten an die Warteschlange untersucht haben, wissen wir außerdem, dass der Prozess das Kopieren eines Puffers vom Userspace in den Kernelspace beinhaltet. Wenn die Nachrichten lang genug sind, werden sie Segment für Segment kopiert. Wenn wir während dieses Prozesses einen Seitenfehler auslösen können, erreichen wir das in Abb. 3.2.3.2 gezeigte Szenario.
Glücklicherweise bietet FUSE die erforderliche Funktionalität. Wir können eine Seite auf FUSE abbilden, und wenn ein Seitenfehler ausgelöst wird, ruft das System unsere FUSE-Lese-Funktion auf, um den Seitenfehler zu behandeln. Indem wir den Lesevorgang anhalten, bis der Unsigned-Underflow den `msg_msg_seg *next`-Zeiger überschreibt, und dann den Send-Nachricht-Prozess fortsetzen, können wir willkürliche Schreibvorgänge erreichen. Der gesamte Prozess ist in Abb. 3.2.3.3 dargestellt.
**Abb. 3.2.3.2 Verwenden von Send Message**
**Abb. 3.2.3.3 FUSE und Send Message**
### 3.2.4 Exploit mit VirtualBox
Gemäß der Markdown-Datei: https://github.com/dcheng69/CVE-2022-0185-Case-Study/blob/main/explot-ubuntu/exploit.md
Sobald die Kompilierung abgeschlossen ist, können Sie die Ergebnisse des Exploits in Abb. 3.2.4.1 sehen.
**Abb. 3.2.4.1 VirtualBox Exploit**
# 4. Behebung der Schwachstelle
## 4.1 Offizielle Patches
Nachdem diese Schwachstelle gemeldet wurde, haben Linux und seine vielen Distributionen Patches zusammengeführt, um diesen Fehler zu beheben.[9] [10] [11]
Im folgenden Screenshot zeigen wir den Patch, der von Linus Torvalds zusammengeführt wurde. Die Behebung des Underflow-Problems besteht einfach darin, die Subtraktionsoperation in eine Addition umzuwandeln.
# 5. Auswirkungen in der Praxis
In diesem Bericht zeigen wir, wie diese Schwachstelle ausgenutzt werden kann, um ein Ubuntu-System zu kompromittieren. Darüber hinaus kann sie potenziell ältere Systeme angreifen, die keine regelmäßigen Sicherheitsupdates erhalten.
In Bezug auf Kubernetes könnte diese Schwachstelle zu Privilege Escalation, Container Escape oder Denial-of-Service-Angriffen führen.
Obwohl es in den Nachrichten keine gemeldeten Verluste durch diese Schwachstelle gibt, unterstreicht dies die Bedeutung der konsequenten Anwendung kritischer Sicherheitsupdates. Der Forscher, der diese Schwachstelle gemeldet hat, ist ein Beispiel für ethische Hacking-Praktiken, die wir alle anstreben sollten.[12]
# Referenzen
[1] https://nvd.nist.gov/vuln/detail/CVE-2022-0185
[2] https://www.hackthebox.com/blog/CVE-2022-0185:_A_case_study
[3] https://ubuntu.com/security/CVE-2022-0185#impact-score
[4] [https://en.wikipedia.org/wiki/Two%27s_complement](https://en.wikipedia.org/wiki/Two's_complement)
[5]https://www.gnu.org/software/c-intro-and-ref/manual/html_node/Unsigned-Overflow.html
[6] https://www.kernel.org/doc/gorman/html/understand/understand011.html
[7] https://leviathan.vip/
[8] https://www.willsroot.io/2021/08/corctf-2021-fire-of-salvation-writeup.html
[9] https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=722d94847de2
[10] https://ubuntu.com/security/CVE-2022-0185
[11] https://access.redhat.com/security/cve/CVE-2022-0185
[12]https://jfrog.com/blog/the-impact-of-cve-2022-0185-linux-kernel-vulnerability-on-popular-kubernetes-engines/
[14] https://github.com/chenaotian/CVE-2022-0185?tab=readme-ov-file
[15] https://www.tutorialspoint.com/two-s-complement
| CVSS v3.1 Metriken | Wert |
|---|
| Angriffsvektor (AV) | Lokal |
| Erforderliche Privilegien (PR) | Keine |
| Benutzerinteraktion (UI) | Keine |
| Vertraulichkeit (C) | Hoch |
| Integrität (I) | Hoch |
| Verfügbarkeit (A) | Hoch |