treehacks/botnet-hackpackBuild a basic Command & Control botnet in C
Dieses Hackpack führt dich durch die Implementierung eines grundlegenden Frameworks, das ein Botnetz charakterisiert. Es könnte hilfreich sein, wenn du bereits Erfahrung mit C hast. Wenn dir dieses Tutorial gefällt, gib diesem Repository einen Stern!
Hinweis: Verwende nichts, was du hier lernst, für böswillige Zwecke. Dieses Hackpack dient ausschließlich als Fallstudie zu Botnetzen zu Bildungszwecken. Die in diesem Hackpack vermittelten Konzepte haben weitreichende Anwendungsmöglichkeiten (grundsätzlich alles, was mit Netzwerken zu tun hat). Am wichtigsten ist, dass dieses Hackpack dazu gedacht ist, lokal getestet und eingesetzt zu werden (teile daher bitte nichts, was du im Zusammenhang mit diesem Hackpack erstellst, mit anderen Hackern). Datenschutz ist wichtig, also respektiere ihn bitte.
Bevor du ein Botnetz baust, ist es wichtig zu verstehen, was ein Botnetz ist. Ein Botnetz ist ein Netzwerk von Computern, die in der Lage sind, Befehle remote zu empfangen und lokal auszuführen. Optional können sie Informationen an andere Knoten im Netzwerk weiterleiten. Sie wurden für alles Mögliche eingesetzt, von verteilten Denial-of-Service-Angriffen bis hin zur weit verbreiteten Verbreitung von Spyware. Du hast vielleicht schon von vielen Botnetzen in der Vergangenheit gehört. Die bekanntesten sind wohl Mirai und Gameover Zeus, die 3,8 Tausend bzw. 3,6 Millionen IoT-Geräte kontrollierten. Es gibt große Unterschiede in der Art und Weise, wie Botnetze bestimmte Aufgaben implementieren. Aber um unser Botnetz erfolgreich zu bauen, müssen wir die folgenden Funktionen in unserem funktionierenden Netzwerk sicherstellen.
Unser Botnetz sollte:
Diese Struktur ist charakteristisch für sogenannte Command & Control-Botnetze. Diese Botnetze haben einen Master-Server und viele Slave-Server. Allerdings ist dieser Stil von Botnetzen veraltet und kann leicht zerstört werden, indem der Zugriff auf die Master-Domain unterbrochen wird. Neuere und ausgefeiltere Botnetze folgen einer Peer-to-Peer-Architektur, bei der Administratorrechte entweder auf alle Knoten oder eine Teilmenge der Knoten im Netzwerk verteilt sind. Diese Botnetze bereiten Sicherheitsexperten große Kopfschmerzen, da es keinen zentralen Kontrollpunkt gibt und sie auf Millionen von Knoten anwachsen können. Das Zerstören solcher Botnetze ist für sich genommen eine interessante Lektüre. Für die Zwecke dieses Hackpacks halten wir die Dinge jedoch einfach. Wir werden einen einfachen Slave-Knoten für ein C&C-Botnetz implementieren.
Dieses Hackpack wird sich hauptsächlich mit der Implementierung der Client-Malware befassen. Für den Master-Server können wir einen Open-Source-TCP-Server namens Netcat verwenden. Netcat hat nichts mit Botnetzen zu tun. Es ist einfach ein praktisches, etabliertes Werkzeug, das wir umfunktionieren können, um Textpakete zu und von Clients zu senden (was im Grunde alles ist, was ein Master ist). Ich habe den Netcat-Server leicht angepasst und zu einer Binärdatei namens „master" kompiliert. Keine weitere Arbeit nötig! Unser Master ist einsatzbereit.
Kommen wir zum interessanteren Teil: dem Empfangen und Ausführen von Remote-Befehlen (um die Tarnung unserer Malware kümmern wir uns später). Das Ziel hier ist es, unseren Slave-Knoten so einfach wie möglich zu gestalten und die oben beschriebenen Anforderungen zu erfüllen. Beachte, dass viele Konstanten in lib/macros.h definiert sind, also kannst du diese gerne verwenden. Alle implementierten Funktionssignaturen finden sich entweder in lib/connect.h oder lib/utils.h.
Öffne die Datei bot.c. Wenn wir einen neuen Knoten in unserem Server starten, sollten wir ihn wahrscheinlich benennen, damit der Master weiß, an welche Clients er Befehle senden soll. Es gibt viele Namenskonventionen, die verwendet werden können. Die Verwendung einer IP-Adresse ist wahrscheinlich am besten, da es sich um eine eindeutige Kennung für jeden Client handelt. Um die Dinge jedoch für normale Menschen lesbarer zu machen, verwenden wir den Benutzernamen des Computers. Die C-Funktion getenv() mit dem Argument "USER" gibt zurück, was der Computer in der Umgebungsvariablen USER gespeichert hat. Hier wird der Benutzername des Benutzers gespeichert, also verwenden wir das. Außerdem: Da dein Slave jetzt läuft, suchen wir nach dem Master. Dazu müssen wir die IP-Adresse unseres Masters kennen. Jedes Netzwerkgerät hat eine IP-Adresse. Sie ist für die Identifizierung anderer Knoten und die Standortadressierung verantwortlich. Außerdem kann der Master viele Server auf verschiedenen Ports betreiben. Wir müssen uns also nicht nur mit dem Master verbinden, sondern auch den richtigen Port angeben. Dieser Port wird vom Master gewählt, kann aber geändert werden. In diesem Hackpack möchten wir lokal testen. Also verwenden wir deinen Computer als unser Netzwerk. Die lokale IP-Adresse jedes Computers (zu der auch „localhost" aufgelöst wird) ist "127.0.0.1". Ich habe im Master angegeben, dass er auf Port 9999 läuft. Mit diesen drei Dingen (Master-IP-Adresse, Master-Port und Slave-Name) können wir eine Kommunikationspipeline zwischen Server und Client starten, die als Socket bezeichnet wird. Übergib diese drei Argumente an die Funktion init_socket(), um einen Socket zu erstellen. init_function() ist kein eingebauter C-Befehl. Vielmehr müssen wir ihn implementieren. Dann müssen wir etwas Speicher auf dem Stack für eingehende Nachrichten reservieren. Seien wir großzügig und verwenden etwa 10 KB Stack-Speicher. Nenne diesen Stack-Zeiger . Schließlich gibt es eine -Anweisung, um anzuzeigen, dass alles gut läuft.
char* name = //Hole den Benutzernamen des Clients und speichere ihn in name
int channel = //Initialisiere einen Kanal mit SERVER, PORT und name;
//Reserviere Stack-Speicher der Größe CMD_LENGTH für Daten vom Typ char. Nenne den Stack-Zeiger msg
printf("%s tritt dem Botnetz bei\n", name);
Wechsle jetzt zu lib/connect.c. Lass uns init_channel() implementieren. Zuerst habe ich einen Stack-Char-Puffer namens msg der Länge CMD_LENGTH und ein spezielles C-Netzwerk-Konstrukt namens server definiert, das Informationen über unsere Verbindung zum Master enthält. Konvertiere zuerst deine übergebene IP-Adresse von einem menschenlesbaren Format (mit Zahlen und Punkten) in ein Binärformat in Netzwerk-Byte-Reihenfolge. Dies geschieht mit einer speziellen C-Funktion namens inet_addr() aus der Socket-Bibliothek. Sie nimmt einfach eine IP-Adresse entgegen und gibt sie in für das Netzwerk nutzbarer Binärform aus. In C können wir ein Netzwerk leicht durch das Ausfüllen der Felder einer Struktur namens sockaddr_in angeben. Unsere Instanz dieser Struktur heißt server. Wir müssen drei Felder dieser Struktur ausfüllen: server.sin_addr.s_addr (die Master-IP-Adresse), server.sin_family (ein 1-Byte-Wert, der die Kommunikationsdomäne angibt) und server.sin_port (der Port, zu dem wir uns mit dem Master verbinden). Die sin_family kann mit C-Makros angegeben werden, die von der Socket-Bibliothek bereitgestellt werden. Normalerweise, wie in diesem Fall, setzen wir dieses Feld auf AF_INET. Das bedeutet, dass unsere Verbindung Netzwerkknoten über ihre IP-Adressen identifiziert, was wir wollen. Es ist jedoch auch möglich, PF_INET zu verwenden, das ähnlich wie ist, aber angibt, dass das Netzwerk alles innerhalb des Protokolls zur Identifizierung bestimmter Knoten verwenden kann. Es gibt auch viele angebliche historische Gründe, warum beide existieren, aber das ist etwas, wovon ich nicht wirklich weiß oder was mich interessiert. Verwende einfach . Zuletzt, wenn wir den Server-Port setzen, müssen wir durch eine spezielle Funktion namens (Host to Network Short) leiten. Dies konvertiert die Daten von der Host-Byte-Reihenfolge in die Netzwerk-Byte-Reihenfolge. Dieses Byte-Reihenfolge-Chaos hat mit etwas zu tun, das Endianness genannt wird. Du kannst mehr darüber lesen.
Schließlich müssen wir die eigentliche Verbindung zwischen Master und Slave definieren! Definiere dazu einen Netzwerk-Socket, über den Daten gesendet werden können. Stell dir vor, der Master hätte viele 'Steckdosen'. Jetzt müssen wir einen 'Stecker' am Slave bauen, der in die 'Wandsteckdosen' des Masters passt. Wir können dies mit der Funktion socket() der Socket-Bibliothek tun. Wie praktisch! socket() nimmt 3 Argumente entgegen: Kommunikationsdomäne, Socket-Typ und ein Protokoll. Für die Kommunikationsdomäne hast du es wahrscheinlich schon erraten: AF_INET. Für den Socket-Typ möchten wir, dass unser Socket einer ist, der Daten einfach in beide Richtungen streamt. Verwende daher das gegebene Makro SOCK_STREAM. Machen wir uns keine Sorgen um das Socket-Protokoll. Dies ist ein ziemlich grundlegendes Netzwerk, also verwenden wir einen Wert von 0, der das Standardprotokoll bezeichnet. Die Funktion gibt einen int zurück, der den Socket repräsentiert. Speichere diesen Wert in channel. Als nächstes wollen wir unseren Socket starten (den Slave in die Wandsteckdose des Masters stecken). Rufe die C-Funktion connect() auf. Diese nimmt drei Argumente entgegen: den Kanal, die sockaddr-Struktur und die Größe der Struktur in Bytes. Wenn connect() eine positive Ganzzahl zurückgibt, war deine Verbindung zum Master erfolgreich! Um unsere neue Verbindung zu testen, senden wir einen Gruß an den Master! Befülle unseren Nachrichtenpuffer und verwende respond() (noch zu implementieren), um über den Kanal an den Master zu senden. Schließlich soll die Funktion diese erfolgreiche Verbindung zurückgeben.
int init_channel (char *ip, int port, char *name) {
char msg[CMD_LENGTH];
struct sockaddr_in server;
server.sin_addr.s_addr = //konvertiere die IP in Netzwerk-Byte-Reihenfolge
server.sin_family = //setze die Kommunikationsdomäne des Servers
server.sin_port = //konvertiere den Port in Netzwerk-Byte-Reihenfolge
int channel = //definiere einen SOCK_STREAM Socket
if(channel < 0) {
perror ("socket:");
exit(1);
}
int connection_status = //verwende den definierten Kanal, um den Slave mit dem Master-Server zu verbinden
if (connection_status < 0) {
perror ("connect:");
exit(1);
}
//sende eine Begrüßungsnachricht an den Master, indem du eine Zeichenkette in msg lädst (Hinweis: snprintf wird sich als nützlich erweisen)
respond (channel, msg);
return channel;
}
Sobald der Slave mit dem Master verbunden ist, muss er ständig auf Nachrichten hören und sofort auf einen Befehl reagieren. Also verwenden wir eine unendliche while-Schleife, um diese Nachrichten zu empfangen und zu parsen. Füge in bot.c unterhalb der printf-Anweisung eine unendliche while-Schleife ein, die zwei Funktionen aufruft: recieve() und parse() in dieser Reihenfolge. Beide Funktionen nehmen den channel und den Stack-Puffer msg als Argumente. Ihre Funktionssignaturen findest du in lib/utils.h. Das sollte etwa so aussehen:
Unendliche Schleife {
recieve(...);
parse(...);
}
Gehe zu utils.c, um recieve() und respond() zu implementieren. recieve() holt Nachrichten aus dem Kanal und respond() sendet Nachrichten über den Kanal zurück. Die Parameter von respond() sind die Socket-Adresse s und unser Stack-Puffer msg_buf. Wir möchten die C-Funktion write() verwenden, um das, was der Stack-Puffer enthält, in den Kanal zu schreiben und dessen Status zurückzugeben. write() benötigt 3 Argumente: Socket-Adresse, den Nachrichtenpuffer und die Länge der Nachricht.
int respond(int s, char *msg_buf) {
//schreibe den Inhalt von msg_buf in Socket s und gib den Status zurück
}
recieve() ist ebenfalls ein einfacher Helfer. Setze den msg-Puffer zurück (Hinweis: verwende memset()). Rufe nun die Socket-Bibliotheksfunktion read() auf, um msg zu lesen. read() nimmt 3 Argumente entgegen: Socket-Adresse, Nachrichtenpuffer und die maximal erwartete Länge der Nachricht.
int recieve(int s, char *msg) {
//setze den msg-Puffer zurück
int read_status = //lese den Inhalt von Socket s in msg
if (read_status) {
perror("log:");
exit(1);
}
return 0;
}
Fast geschafft! Unser Botnetz ist im Moment ziemlich langweilig. Es kann nur Nachrichten über einen Socket empfangen und senden. Lass es uns tatsächlich das ausführen lassen, was es auf dem Terminal empfängt. Wir implementieren zuerst die Funktion parse(). Sie macht genau das, was der Name sagt: Sie parst den Befehl. Wir könnten eine einfache Fehlerprüfung durchführen, um zu sehen, ob eine Nachricht fehlerhaft ist. Außerdem möchten wir Nachrichten, die empfangen wurden, aber nicht für sie bestimmt sind, stillschweigend ignorieren. Die Nachricht wird vom Master als (Name des Botnetzes):(auszuführender Befehl) formatiert. Das erstere habe ich bereits für dich erledigt. Wenn die beiden Prüfungen bestanden sind, übergeben wir den Befehl an die Funktion execute().
int parse (int s, char *msg, char* name) {
char *target = msg;
//prüfe, ob die msg für diesen Client bestimmt war. Wenn nicht, dann verwerfe das Paket stillschweigend, indem du 0 zurückgibst
char *cmd = strchr(msg, ':');
if (cmd == NULL) {
printf("Falsche Formatierung. Referenz: TARGET: command");
return -1;
}
//passe den cmd-Zeiger an den Anfang des eigentlichen Befehls an
//passe das terminierende Zeichen an das Ende des Befehls an
//gebe eine lokale Anweisung aus, die den empfangenen Befehl beschreibt
execute (s, cmd);
return 0;
}
Jetzt zum coolen Teil. execute() sollte den empfangenen Befehl in das Terminal leiten und jede Ausgabe über den Socket zurück an den Master schreiben. Erstelle einen Stack-Puffer, um jede Eingabezeile zu speichern. Verwende dann die C-Funktion popen(), um die Eingabe auszuführen und die Ausgabe in der Datei f zu speichern (es gibt viele Möglichkeiten, dies zu tun. Du kannst dein Botnetz anpassen, um wirklich coole Dinge mit Master-Eingaben zu tun und autonome Kooperationen / Updates mit anderen Knoten im Botnetz durchzuführen. Fühle dich frei, so kreativ zu sein, wie du möchtest. Wir bleiben vorerst bei unserem einfachen Ziel). Parse durch f Zeile für Zeile und schicke alles durch deinen Socket. Schließe f und du bist fertig!
int execute (int s, char *cmd) {
FILE *f = //verwende popen, um den Befehl lokal auszuführen
if (!f) return -1;
while (!feof (f)) {
//parse durch f Zeile für Zeile und sende jede Ausgabe zurück an den Master
}
fclose(f);
return 0;
}
Kompiliere dein neues Botnetz mit dem folgenden Terminalbefehl:
gcc -lcurl lib/connect.c lib/utils.c bot.c -o bin/slave
Führe bin/master in einem Terminalfenster und bin/slave in anderen Fenstern aus. Gib Befehle als (Slave-Benutzername):(entfernter Terminalbefehl) ein. Herzlichen Glückwunsch! Du hast gerade ein Botnetz gebaut!
Es gibt wirklich coole Dinge, die du tun kannst, um Malware zu tarnen und bereitzustellen. Tatsächlich ist es ein eigenes Fachgebiet. Ein Beispiel dafür, was du tun kannst, ist, die Malware als Bild zu tarnen. Lass uns ein Bild eines Pandas verwenden. Ich habe eine einfache Funktion in utils.c hinzugefügt, die ein Bild eines Pandas herunterlädt und es in der Vorschau anzeigt. Dies vermittelt dem Benutzer den Eindruck, ein Bild eines Pandas zu öffnen, obwohl er in Wirklichkeit deine Malware ausführt. Um dies hinzuzufügen, füge die folgenden Codezeilen in bot.c ein:
char* open_cmd = alias_img();
system(open_cmd);
free(open_cmd);
Klicke als nächstes mit der rechten Maustaste auf ein beliebiges Bild und wähle „Informationen". Wiederhole dies mit bin/slave. Ziehe die Bildminiatur auf die ausführbare Miniatur von bin/slave. Dies sollte das Aussehen auf dem Desktop ändern. Allerdings fehlt uns noch die charakteristische .png-Dateiendung. Benenne deine ausführbare Datei um in
panda⒈png
Jetzt sieht dies wie eine png-Datei aus. Wir verwenden jedoch das Unicode-Zeichen „1." anstelle von „.", um zu verbergen, dass es sich immer noch um ein Unix-Executable handelt. Es gibt viele weitere glaubwürdige Unix-Tricks, die angewendet werden können, wie das LEFT-TO-RIGHT OVERRIDE-Zeichen, um ausführbare Dateinamen zu tarnen. In extremeren Fällen kannst du Code in Bilder und Datei-Makros einbetten, um gleichzeitig ausgeführt zu werden, wenn der Host geöffnet wird (ähnlich wie ein Trojanisches Pferd...). Da jedoch niemand bei TreeHacks ein Cyberkrimineller ist, sollten wir uns nicht allzu sehr um diese Techniken kümmern ;).
Jetzt, da du ein voll funktionsfähiges Botnetz hast, gibt es viele Erweiterungen, mit denen du dich herausfordern kannst. Unser Botnetz ist immer noch ziemlich uninteressant. Es kann nicht viel tun, es sei denn, der Benutzer klickt jedes Mal darauf. Hier sind einige Vorschläge:
Botnetze können für Angreifer wirklich zuverlässige Quellen für bösartige Aktivitäten werden, wenn sie sich irgendwie auf einem Computer halten, selbst wenn der Computer heruntergefahren wird. Versuche, damit zu spielen, wie du deinen Slave bei jedem Start erneut initiieren kannst. Auf diese Weise infiziert ein Benutzer, sobald er auf die Malware klickt, seinen Computer, bis er ihn bereinigt. Ein Vorschlag, dies zu erreichen, ist, deinen ausführbaren Prozess in einen Daemon umzuwandeln. Erstelle dann eine Konfigurationsdatei, die deine ausführbare Datei zu einer Liste von Daemons hinzufügt, die beim Start ausgeführt werden sollen (Cloud-Speicheranwendungen, Team-Messaging-Plattformen usw. tun dies bereits). Erfahre mehr darüber hier.
Die Implementierung eines Peer-to-Peer-Netzwerks ist nichts anderes als eine Neuanordnung des Netzwerkdesigns. Der Schlüssel zu einem P2P-Netzwerk ist jedoch, dass der Administrator/Angreifer über jeden Knoten im Netzwerk die Master-Kontrolle erlangen kann. Der Angreifer sollte also über einen Master-Key und eine verschlüsselte Anmeldung verfügen, die die Master-Kontrolle über jeden Knoten ermöglicht. Lies mehr darüber, wie Peer-to-Peer-Netzwerke funktionieren hier.
Die Master-Slave-Struktur, die du implementiert hast, ist nicht sehr sicher. Die Slaves können leicht befreit werden, indem der Master-Knoten zerstört wird. Optimalerweise würdest du zu einem P2P-Design wechseln. Du kannst die Sicherheit des Masters jedoch auch leicht erhöhen, indem du seine Befehle zufällig über eine Reihe von angreiferkontrollierten Bots leitest, bevor sie im Botnetz bereitgestellt werden. Dies erschwert es Experten, das Befehlszentrum zu lokalisieren und Botnetz-Anrufe zwischen Angreiferknoten und Client-Knoten zurückzuverfolgen.
Noch wichtiger ist vielleicht, dass du mehr mit Netzwerken herumspielen möchtest. Unser Netzwerk ist so einfach wie es nur geht. In vielerlei Hinsicht ist es extrem schwach und definitiv nicht streng. Daher möchtest du möglicherweise etablierte Protokolle für Netzwerke wie Internet Relay Chat (IRC) erkunden, um ein ordentlicheres Netzwerk aufzubauen. Obwohl es eine Weile dauert, ist es äußerst lehrreich und eine gut investierte Zeit. Lies mehr darüber hier: https://oramind.com/tutorial-how-to-make-an-irc-server-connection/.
In diesem Hackpack haben wir ein frei verfügbares Open-Source-Projekt als Ersatz für unseren Master-Server verwendet. Es gibt jedoch viele Nachteile. Erstens können wir unseren Master-Server nicht anpassen, um automatisierte Befehle durch unser Netzwerk zu senden. Er ist ausschließlich auf die Verwendung der Befehlszeileneingabe beschränkt. Zweitens ist dir vielleicht aufgefallen, dass alle Slaves im Botnetz jeden Befehl erhalten. Unsere Bedingung für die Ausführung besteht darin, zu prüfen, ob der Zielname mit dem Slave-Namen übereinstimmt. Wenn nicht, wird der Befehl stillschweigend verworfen. Dies wird als Broadcast-Netzwerk bezeichnet. Etwas Optimaleres könnte ein Multicast-Netzwerk sein. In einem Broadcast-Netzwerk leitet ein Knoten Pakete an alle seine verbundenen Knoten weiter. In einem Multicast-System kann eine bestimmte Teilmenge von Knoten angegeben werden, die die Pakete empfangen sollen. Darüber hinaus verschiebt die Verwendung eines Multicast-Netzwerks die Befehlszuweisung vom Client zum Master-Server, wo sie hingehört. Implementiere deinen eigenen Master, um das Botnetz von Broadcast auf Multicast umzustellen.
Eine umfassende Anleitung zur Netzwerkprogrammierung findest du hier: http://beej.us/guide/bgnet/output/html/multipage/index.html.
Hoffe, es hat Spaß gemacht!
MIT
HackPacks werden vom TreeHacks-Team entwickelt, um Hackern zu helfen, großartige Projekte auf unserem Hackathon zu bauen, der jedes Jahr im Februar an der Stanford University stattfindet. Wir glauben, dass jeder, unabhängig von seinem Kenntnisstand, lernen kann, großartige Dinge zu erschaffen, und dies ist eine Möglichkeit, wie wir die Hacker-Kultur fördern. Wir veröffentlichen unsere Hackpacks (zusammen mit unserer internen Technologie) als Open Source, damit jeder daraus lernen und sie nutzen kann! Verwende sie gerne bei deinen eigenen Hackathons, Workshops und allem anderen, was das Bauen fördert :)
Wenn du daran interessiert bist, an TreeHacks teilzunehmen, kannst du dich während des Bewerbungszeitraums auf unserer Website bewerben.
Du kannst uns hier auf GitHub folgen, um die gesamte Open-Source-Arbeit zu sehen, die wir leisten (wir lieben Issues, Beiträge und Feedback jeglicher Art!), und auf Facebook, Twitter und Instagram, um allgemeine Updates von TreeHacks zu erhalten.
msgprintfAF_INETAF_INETporthtons()msginit_channel()