Nachahmung von Cryptomining-Angriffen: Ein tiefer Einblick in die Ressourcenauslastung durch GPU-Programmierung

Kryptomining hat an Popularität gewonnen, angetrieben durch den wachsenden Wert von Kryptowährungen wie Bitcoin und Ethereum. Da es einfacher denn je ist, an geleakte Zugangsdaten zu gelangen, suchen Angreifer nach Möglichkeiten, daraus Profit zu schlagen, was zu einem Anstieg von böswilligem Cryptomining oder Cryptojacking geführt hat. Hier kapern Angreifer Computerressourcen, um ohne Zustimmung des Eigentümers Kryptowährungen zu schürfen. Diese Cryptojacking-Angriffe können die Systemleistung erheblich beeinträchtigen, die Stromkosten erhöhen und die Lebensdauer der Hardware verkürzen. Da Unternehmen mit einer Knappheit an Grafikprozessoren zu kämpfen haben, ist es umso wichtiger, dieses Problem anzugehen. Unternehmen benötigen effektive Möglichkeiten, um diese Bedrohungen zu verstehen und zu mindern. Hier kann die Emulation von Cryptomining-Angriffen helfen.

In dieser Untersuchung haben wir uns zum Ziel gesetzt, Cryptojacking-Angriffe zu simulieren. Aus Gründen der Ressourceneffizienz und Sicherheit wurde dies durch die Erstellung von Hashes erreicht. Mit diesen Funktionen können Organisationen ihren Ansatz validieren und testen, ob sie in der Lage sind, sich gegen echte Angriffe zu verteidigen, die ihre Leistung beeinträchtigen und ihre Ressourcen erschöpfen können, was zu Budgetproblemen und übermäßigem Verbrauch führt.

Was ist Cryptomining und Cryptojacking?

Bevor wir auf unsere Zielsetzung und unseren Ansatz eingehen, wollen wir kurz erläutern, wie Kryptomining und Kryptowährungen funktionieren.

Eine Kryptowährung basiert auf einer Reihe von Axiomen und Einschränkungen, auf die sich alle Miner, Mitwirkenden und Nutzer geeinigt haben und an die sie sich als Voraussetzung halten. Im Fall von Bitcoin handelt es sich beispielsweise um einen Proof of Work, einen sha256-Hash mit einer bestimmten Anzahl von Nullen. Solche Voraussetzungen für den „Besitz“ einer virtuellen Währung können bei den verschiedenen Kryptowährungen unterschiedlich sein.

Bei jeder Währungsübertragung wird eine Transaktionsnachricht über die Blockchain der Kryptowährung gesendet, in der der aktualisierte Besitz der Währung angegeben ist. Diese Transaktionsnachricht wird dann von den Validatoren der Blockchain, umgangssprachlich auch „Miner“ genannt, validiert. Ein neuer Block mit einem Hash, aktuellen Transaktionen und Zeitstempeln wird erstellt und in der Blockchain gespeichert.

So funktioniert es von der Marktseite aus. Im Backend muss etwas die Freigabe neuer Coins in Umlauf auslösen. Ein Krypto-Miner ist das Programm, das Rechenleistung nutzt, um Hashes zu erstellen, die den Anforderungen des Coins entsprechen.

Wir haben alle gehört und gesehen, wie die Bitcoin-Preise in die Höhe geschossen sind und wie Kryptowährungen weltweit Strom verbrauchen. Ist das alles nur dazu da, um ein paar Hashes zu erzeugen? Eine Voraussetzung ist ein rechenintensiver mathematischer Algorithmus, der viele Berechnungen erfordert, um eine eindeutige Eins-zu-Eins-Umwandlung zwischen der Eingangszahl und der Ausgangszahl zu erzeugen. Dies erfordert eine erhebliche Rechenleistung, daher der Wunsch, die Geräte anderer Leute zu nutzen.

 

In modernen Computern dauert die Ausführung solcher Funktionen einmal weniger als eine Millisekunde. Wenn Sie jedoch einen Krypto-Miner ausführen, möchten Sie diese Umwandlung so oft wie möglich in kürzester Zeit ausführen. So erhalten Sie die meisten Ergebnisse und stoßen auf einen Hash, der den Anforderungen der gesuchten Kryptowährung entspricht.

In einem Artikel von Unblock Talent heißt es:

„Beim Krypto-Mining werden mithilfe eines Computers riesige Mengen an Hashes berechnet, während nach bestimmten Ergebnissen gesucht wird. Bei Bitcoin können Hashes, die mit einer 0 beginnen, neue Bitcoins generieren, obwohl dies mit der Zeit immer schwieriger geworden ist. Da Hashes einzigartig sein müssen, gibt es nur eine begrenzte Anzahl von Hashes, die mit 0 beginnen. Diejenigen, die mit einer, zwei oder drei 0 beginnen, wurden alle vor langer Zeit abgebaut, wobei moderne Hashes mindestens Deshalb ist es so viel schwieriger geworden, diese wertvollen Coins zu schürfen. Man braucht viel mehr Rechenleistung, um einen Hash mit so vielen Nullen zu finden.“

Cyptojacking ist eine Form des böswilligen „Cryptomining“, bei der eine Organisation infiltriert wird, um ihre Ressourcen auszunutzen und „Cryptomining“ durchzuführen.

Die Bedeutung von GPUs

Cryptomining wirft eine grundlegende Frage zur Leistung auf. Sollten GPUs oder CPUs für Cryptomining (und Cryptojacking) verwendet werden?

Nehmen wir an, wir arbeiten mit einer CPU der mittleren Leistungsklasse. In den meisten Fällen verfügt die CPU über etwa 16 logische Prozessoren. Das bedeutet, dass theoretisch bis zu 16 Miner gleichzeitig ausgeführt werden können, die etwa 3000 Hashes pro Minute generieren.

Wenn die Hash-Funktion auf einer GPU statt auf einer CPU ausgeführt wird, führt dies zu drastisch unterschiedlichen Ergebnissen.

GPUs sind für Komplexität und große Mengen einfacher paralleler Operationen ausgelegt, wodurch sie wesentlich effizienter als CPUs sind, wenn es darum geht, mehrere Aufgaben schnell zu lösen. Eine typische GPU kann Tausende von Kernen haben, im Vergleich zu den wenigen Kernen (selbst wenn sie mit mehreren Threads arbeiten) in einer CPU. Dadurch kann eine GPU Tausende von Operationen gleichzeitig ausführen.

Aufgrund ihrer Beschaffenheit können GPUs Hashes viel schneller berechnen als CPUs. Während eine CPU etwa 3000 Hashes pro Minute bereitstellen kann, kann eine GPU je nach spezifischem GPU-Modell und verwendetem Algorithmus potenziell Millionen von Hashes im gleichen Zeitraum berechnen.

Da derjenige, der die Aufgaben am schnellsten löst, alles gewinnt, sind organisatorische GPUs ein bedeutender und lukrativer Vorteil für Crypto-Miner.

Der Angriff: Was wir getan haben

Wir wollten eine Cryptojacking-Kampagne mit Nutzlast und Angriffsablauf nachstellen und dabei den Ressourcenverbrauch und die Kommunikation auf eine externe Blockchain beschränken.

Dazu mussten wir uns eingehender mit der GPU-Programmierung und der strategischen Manipulation von CPU- und GPU-Ressourcen befassen.

Wir haben ein modulares Skript entwickelt, das:

• Kann in jeder Umgebung ausgeführt werden: Ermöglicht das Testen in verschiedenen Umgebungen und Szenarien
• Erfordert nicht viele Voraussetzungen: Leichtgewichtig für eine einfache Implementierung, mit wenig bis gar keinen Änderungen an Ihrer Umgebung.
• Kann GPU- und CPU-Ressourcen nutzen: Bietet die Möglichkeit, die Bereitschaft für Cryptojacking-Kampagnen zu testen, auch wenn Sie keine GPUs haben (da einige Miner wie XMRig stark auf CPUs angewiesen sind)
• Verwendet einfache Betriebssystemfunktionen, um EDRs zu umgehen: Macht es für EDRs schwierig, sie zu erkennen.
• Läuft nur für eine bestimmte Zeit, bevor sie sich selbst beendet: Validierung mit minimalen Kosten durch Begrenzung der Nutzung von Cloud-Ressourcen

Unsere ausführbare Datei wurde, wie die von ihr simulierten „Cryptominer“, so konzipiert, dass sie „einfach“ ist. Wir wollten keine Treiber oder Kernel-Space-Komponenten einbeziehen, damit unsere ausführbare Datei funktioniert. Da die ausführbare Datei Hashes mithilfe herkömmlicher Bibliotheken berechnet, gibt es für den EDR nichts zu melden.

Entwicklung des Skripts

Wir haben uns aufgrund seiner Modularität für Golang als Skriptsprache entschieden. Golang gilt aufgrund einiger seiner Eigenschaften als eine der flexibelsten Programmiersprachen:

1. Cross-Compilation: Go verfügt über eine integrierte Unterstützung für Cross-Compilation. Sie können ein Golang-Codeprojekt für jedes unterstützte Zielbetriebssystem und jede unterstützte Zielarchitektur von jedem anderen unterstützten System aus kompilieren. Dies wird durch die Umgebungsvariablen GOOS und GOARCH erleichtert.
2. Einzelne Binärdatei: Go kann Golang-Quellcode in einzelne, statisch verknüpfte Binärdateien kompilieren; alle Abhängigkeiten sind in der ausführbaren Datei enthalten, sodass sie einfach verteilt und bereitgestellt werden kann, ohne dass man sich Gedanken über fehlende Bibliotheken machen muss.

Mit Golang können Sie auf Anfrage eine ausführbare Datei für jede Umgebung erstellen. Es ist nicht notwendig, separate Projekte, Bibliotheken usw. zu erstellen, da alles in unserem Go-Projekt enthalten ist.

Als Nächstes wollten wir unserem Go-Projekt C-Code hinzufügen, um mit den Betriebssystemfunktionen zu interagieren – hauptsächlich im GPU-Drain (wir werden gleich näher darauf eingehen). Go verfügt über eine hilfreiche Funktion namens CGO, die eine Möglichkeit bietet, Go und C zu verbinden, um die Interaktion zwischen den beiden Sprachen zu ermöglichen.

Bei der Verwendung von CGO kann Go die erforderlichen Bibliotheken nicht statistisch verknüpfen, um den C-Code auszuführen, aber es gibt eine Funktion in Go namens Tags, die die erforderliche Trennung zwischen dem GPU-Code und dem CPU-Code herstellt.

Mit Tags können Sie verschiedene Teile des Codes markieren und dann anfordern, sie unterschiedlich zu kompilieren.

Wir haben das Projekt so ausgerichtet, dass nur dann Seiten kompiliert werden, wenn bei Verwendung des Go-Build-Befehls eine Flagge für dieses spezifische Tag angezeigt wird. Wir können jetzt je nach System und den vorhandenen Ressourcen unterschiedlichen Code ausführen – und das alles aus demselben Projekt heraus! Dadurch konnten wir ein einziges Projekt ausführen und erstellen, das für alle Maschinen geeignet ist, ohne dass es zu Kompatibilitätsproblemen mit der jeweiligen Maschine kommt.

Rechenleistung: CPUs und GPUs

Lassen Sie uns näher darauf eingehen, wie wir mit den Ressourcen des Computers gearbeitet haben:

Arbeiten mit der CPU

Bei der Erstellung der ausführbaren Datei war es wichtig sicherzustellen, dass sie sowohl die CPU als auch die GPU nutzen konnte. Während die GPU häufiger vorkommt, erfolgen die meisten Angriffe in der Cloud auf Ressourcen, die nur über CPUs verfügen.

Go verfügt über wertvolle Funktionen, die als Goroutinen und Kanäle bezeichnet werden. Anstatt die Autorität der Thread-Erstellung an das Betriebssystem zu übergeben, kann der eigene Mechanismus von Go Threads und die Thread-Kommunikation verarbeiten. Unsere ressourcenintensive Operation umfasst die Verwendung einer Funktion, die Goroutinen erstellt. Die Goroutinen haben die Aufgabe, sha256-Hashes zu erstellen, während sie kontinuierlich versuchen, sie mit einer fest codierten Voraussetzung abzugleichen, bis ein logischer Killswitch aktiviert wird und alle Operationen gestoppt werden.

Nachdem ein passender Hash gefunden wurde, wird er über einen erstellten Kanal gesendet, der als Pipe für alle Goroutinen dient, die ihre Hashes gleichzeitig ablegen. Nachdem die Routinen beendet sind, können wir einfach alle Hashes aus dem Kanal sammeln.

Arbeiten mit der GPU

Die GPU-Berechnung wird heutzutage hauptsächlich für die Berechnung komplexer Gleichungen in den Bereichen KI, Datenwissenschaft und Big Data verwendet. Für die Interaktion mit einer GPU ist, wie bei jeder Hardware in einem System, ein Toolkit erforderlich. Für die Interaktion mit dem Netzwerktreiber benötigt man beispielsweise WinAPI, um Benutzercode in Kernel-Space-Anfragen zu übersetzen. Ebenso benötigt man für die Arbeit mit GPUs ein spezielles Toolkit, das vom GPU-Hersteller erstellt oder unterstützt wird. In unserem Fall haben wir zwei mögliche Toolkits, die wir verwenden können: das CUDA-Toolkit oder das OpenCL-Toolkit.

Die beiden Kits weisen einige Unterschiede auf. CUDA wurde speziell für NVIDIA-Produkte entwickelt. Es ist nativ in das Ökosystem integriert. OpenCL ist ein offener Standard, der von der Khronos Group gepflegt wird und mit allen GPU-Herstellern zusammenarbeitet.

Wir haben uns für OpenCL entschieden, um Modularität und Mobilität zu gewährleisten.

Bei der Verwendung des OpenCL-Toolkits in Go sind wir auf eine Go-Bibliothek angewiesen, die C-Code verwendet, um OpenCL-Funktionen aus OpenCL-DLLs aufzurufen. Dabei sollten Sie CGo verwenden.

Die GPU befindet sich außerhalb unseres bekannten Kontexts von Threads, Garbage Cleaners und anderen Vorgängen, die vom Betriebssystem verwaltet werden. Es handelt sich um ein Gerät, das in einem eigenen Kontext arbeitet und speziell dafür kompilierte Programme erfordert.

Wenn wir mithilfe des OpenCL-Toolkits Code für die GPU schreiben, müssen wir eine völlig neue logische Umgebung von Grund auf neu erstellen. Während das Betriebssystem die meisten Aktionen im Zusammenhang mit der CPU übernimmt, müssen wir die Variablen für die GPU selbst erstellen und pflegen.

Dieses Programm ist ein Beispiel für die Ausführung eines einfachen Kernels, der zwei Zahlen addiert.

Lassen Sie uns die Schritte zur Erstellung dieses Programms durchgehen:

1. Nachdem wir die Liste der verfügbaren Geräte auf dem Computer gefunden haben, erstellen wir eine logische Umgebung für das GPU-Gerät. Diese logische Umgebung wird für alle programmierbezogenen Aktionen verwendet. Wir erstellen unsere benötigten Eingabe-/Ausgabepuffer darauf, unsere Befehlswarteschlange, und wir erstellen und führen unseren GPU-Kernel darauf aus.

cl_int ret = clGetPlatformIDs(1, &platformId, &retNumPlatforms);
ret = clGetDeviceIDs(platformId, CL_DEVICE_TYPE_DEFAULT, 1, &deviceId, &retNumDevices);

// Create an OpenCL context
cl_context context = clCreateContext(NULL, 1, &deviceId, NULL, NULL, &ret);

2.Wir definieren die für die Kernel-Ausführung erforderlichen Eigenschaften innerhalb des Kontexts. Dazu gehören eine Befehlswarteschlange, aus der gelesen und ausgeführt werden soll, sowie Puffer für die Argumente, die der Kernel verwenden wird.

// Create a command queue
cl_command_queue commandQueue = clCreateCommandQueueWithProperties(context, deviceId, 0, &ret);

 

// Create memory buffers on the device
cl_mem d_a = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, N * sizeof(int), h_a.data(), &ret);
cl_mem d_b = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, N * sizeof(int), h_b.data(), &ret);
cl_mem d_c = clCreateBuffer(context, CL_MEM_WRITE_ONLY, N * sizeof(int), NULL, &ret);

3. Wir geben Befehle ein, um ein passendes Programm für unseren Kernel zu erstellen, bauen es und setzen seine Parameter, um es für die Ausführung vorzubereiten.

// Create a program from the kernel source
cl_program program = clCreateProgramWithSource(context, 1, &kernelSource, NULL, &ret);

// Build the program
ret = clBuildProgram(program, 1, &deviceId, NULL, NULL, NULL);

// Create the OpenCL kernel
cl_kernel kernel = clCreateKernel(program, „addVectors“, &ret);

+++++

// Set the kernel arguments
ret = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&d_a);
ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&d_b);
ret = clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&d_c);

4. Zuletzt führen wir den Kernel aus, lesen die Antwort aus seinem Puffer, überprüfen unsere Ergebnisse und räumen hinter uns auf.

// Execute the OpenCL kernel on the list
size_t globalItemSize = N;
size_t localItemSize = 64;
ret = clEnqueueNDRangeKernel(commandQueue, kernel, 1, NULL, &globalItemSize, &localItemSize, 0, NULL, NULL);

// Read the memory buffer d_c on the device to the local variable h_c
ret = clEnqueueReadBuffer(commandQueue, d_c, CL_TRUE, 0, N * sizeof(int), h_c.data(), 0, NULL, NULL);

 

// Verify the result
std::cout << "Computation completed successfully" << std::endl;
// Clean up
clReleaseKernel(kernel);
clReleaseProgram(program);
clReleaseMemObject(d_a);
clReleaseMemObject(d_b);
clReleaseMemObject(d_c);
clReleaseCommandQueue(commandQueue);
clReleaseContext(context);
return 0;
}

Und das war’s. Wir haben die Leistung der GPU-Berechnung in Go mithilfe von OpenCL erfolgreich genutzt, indem wir sorgfältig eine benutzerdefinierte Umgebung eingerichtet, den Speicher verwaltet und einen Kernel ausgeführt haben, um Hochleistungsaufgaben auszuführen.

Mögliche Szenarien für diesen Angriff

Als wir darüber sprachen, warum Modularität und Mobilität für uns wichtig sind, erwähnten wir die Möglichkeit, diese ausführbare Datei in vielen verschiedenen Orchestrierungen auszuführen. Hier sind einige Beispiele:

• On-Prem-Umgebungen

Das Skript kann auf jedem Windows- oder Linux-Rechner in einem lokalen Netzwerk ausgeführt werden, einschließlich virtueller und physischer Rechner.

• Kubernetes-Umgebungen

Das Skript kann auch als Daemon-Set verwendet werden, um die Kontrolle über die GPU-Knoten eines Kubernetes-Clusters zu erlangen, oder sogar als einfacher Pod innerhalb des Clusters.

• Cloud-Umgebungen

Schließlich kann das Skript auch in Cloud-Umgebungen ausgeführt werden. Die Ausführung in Cloud-Umgebungen ist aufgrund der einfachen Kontrolle über Cloud-Rechner sehr praktisch geworden. Da der Prozess der Erstellung und Ausführung einer bösartigen Krypto-Mining-Kampagne zudem immer effizienter und einfacher zu bewerkstelligen ist, können mehr Angreifer diese Art von Kampagnen einsetzen, wodurch sie immer häufiger werden.

Die Kosten von Cryptojacking

Laut Sysdig „muss ein Angreifer im Durchschnitt eine Cloud-Rechnung in Höhe von 430.000 US-Dollar verursachen, um 8.100 US-Dollar zu verdienen. Er verdient 1 US-Dollar für jede 53 US-Dollar, die seinem Opfer in Rechnung gestellt werden.“ Kurz gesagt, im Gegensatz zu anderen Angriffen ist der Zugriff auf das Netzwerk bei einem Cryptojacking-Angriff weniger wirkungsvoll, sondern es sind die hohen Kosten, die mit der Aktivität des Angreifers verbunden sind.

Bei der Erstellung unserer Simulation haben wir versucht, dieses Verhalten nachzuahmen, ohne dem Benutzer tatsächlich hohe Kosten zu verursachen. Deshalb funktioniert unser Skript in Schüben. Der Benutzer kann abschätzen, ob seine Systemüberwachung für einen Cryptojacking-Angriff bereit ist oder nicht.

Deshalb ist es so wichtig, auf Cryptomining zu testen. So können IT-Abteilungen sehen, wie ihre Systeme auf einen echten Cryptojacking-Angriff reagieren würden. Durch das Verständnis der spezifischen Auswirkungen auf die CPU- und GPU-Leistung können Organisationen effektivere Überwachungs- und Eindämmungsstrategien entwickeln, die eine Feinabstimmung der Ressourcenzuweisung ermöglichen und die allgemeine Sicherheitslage verbessern. Organisationen können auch Schwachstellen in ihrer Infrastruktur identifizieren und vorbeugende Maßnahmen zu deren Stärkung ergreifen. Dieser proaktive Ansatz erhöht nicht nur die Sicherheit, sondern stellt auch sicher, dass legitime Anwendungen die Ressourcen erhalten.

Abwehr: Wie man sich vor Crypto-Mining-Angriffen schützt

Um sich vor Crypto-Mining-Angriffen zu schützen, sollten Organisationen eine mehrschichtige Sicherheitsstrategie umsetzen. Dazu gehören:

1. Pentesting: Führen Sie regelmäßig Penetrationstests durch, die Cryptojacking-Angriffe simulieren, um Schwachstellen aufzudecken.
2. Regelmäßige Überwachung: Überwachen Sie kontinuierlich die CPU- und GPU-Auslastung, um ungewöhnliche Spitzen zu erkennen, die auf Cryptojacking hindeuten könnten. Ergreifen Sie sofort Maßnahmen, um den Vorfall zu untersuchen und zu beheben.
3. Endpunktsicherheit: Setzen Sie Endpunktschutzlösungen ein, die schädliche Kryptomining-Software identifizieren und blockieren können.
4. Netzwerksicherheit: Verwenden Sie Netzwerküberwachungstools, um verdächtige Datenverkehrsmuster im Zusammenhang mit Mining-Vorgängen zu erkennen.
5. Software-Patches: Halten Sie alle Software und Systeme auf dem neuesten Stand, um Schwachstellen zu beheben, die von Krypto-Hackern ausgenutzt werden könnten.
6. Benutzerschulung: Informieren Sie Ihre Mitarbeiter über die Risiken von Krypto-Hacking und darüber, wie sie potenzielle Anzeichen eines Angriffs erkennen können.

Durch die Simulation von Cryptomining-Angriffen können sich Organisationen besser auf diese neu auftretende Bedrohung vorbereiten und sich gegen sie verteidigen, um sicherzustellen, dass ihre Systeme angesichts der sich ständig weiterentwickelnden Cyber-Herausforderungen sicher und effizient bleiben.

Quelle: Pentera-Blog

---

Ihr Kontakt zu uns:

Matan Katz, Regional Development

Hier direkt einen Termin buchen:

https://pentera.oramalthea.com/c/MatanKatz

Oliver Meroni, Regional Sales Manager Switzerland & Austria, Pentera

Hanspeter Karl, Area Vice President DACH, Pentera