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

Translated ['src/macos-hardening/macos-security-and-privilege-escalation

Browse Source
This commit is contained in:
Translator 2025-01-12 19:45:26 +00:00
parent d29205633b
commit 5f760331b5
31 changed files with 218 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md
View File

@ -4,8 +4,8 @@
## Informazioni di Base
Se non sai cos'è Electron, puoi trovare [**molte informazioni qui**](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/electron-desktop-apps/index.html#rce-xss--contextisolation). Ma per ora sappi solo che Electron esegue **node**.\
E node ha alcuni **parametri** e **variabili d'ambiente** che possono essere utilizzati per **far eseguire altro codice** oltre al file indicato.
Se non sai cos'è Electron, puoi trovare [**moltissime informazioni qui**](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/electron-desktop-apps/index.html#rce-xss--contextisolation). Ma per ora sappi solo che Electron esegue **node**.\
E node ha alcuni **parametri** e **variabili d'ambiente** che possono essere utilizzati per **eseguire altro codice** oltre al file indicato.
### Fusi di Electron
@ -13,7 +13,7 @@ Queste tecniche saranno discusse in seguito, ma recentemente Electron ha aggiunt
- **`RunAsNode`**: Se disabilitato, impedisce l'uso della variabile d'ambiente **`ELECTRON_RUN_AS_NODE`** per iniettare codice.
- **`EnableNodeCliInspectArguments`**: Se disabilitato, parametri come `--inspect`, `--inspect-brk` non saranno rispettati. Evitando in questo modo l'iniezione di codice.
- **`EnableEmbeddedAsarIntegrityValidation`**: Se abilitato, il **file** **`asar`** caricato sarà **validato** da macOS. **Prevenendo** in questo modo **l'iniezione di codice** modificando i contenuti di questo file.
- **`EnableEmbeddedAsarIntegrityValidation`**: Se abilitato, il **file** **`asar`** caricato sarà **validato** da macOS. **Prevenendo** in questo modo l'**iniezione di codice** modificando i contenuti di questo file.
- **`OnlyLoadAppFromAsar`**: Se questo è abilitato, invece di cercare di caricare nell'ordine seguente: **`app.asar`**, **`app`** e infine **`default_app.asar`**. Controllerà e utilizzerà solo app.asar, garantendo così che quando è **combinato** con il fuso **`embeddedAsarIntegrityValidation`** sia **impossibile** **caricare codice non validato**.
- **`LoadBrowserProcessSpecificV8Snapshot`**: Se abilitato, il processo del browser utilizza il file chiamato `browser_v8_context_snapshot.bin` per il suo snapshot V8.
@ -46,7 +46,7 @@ Nelle applicazioni macOS, questo si trova tipicamente in `application.app/Conten
grep -R "dL7pKGdnNz796PbbjQWNKmHXBZaB9tsX" Slack.app/
Binary file Slack.app//Contents/Frameworks/Electron Framework.framework/Versions/A/Electron Framework matches
```
Puoi caricare questo file in [https://hexed.it/](https://hexed.it/) e cercare la stringa precedente. Dopo questa stringa puoi vedere in ASCII un numero "0" o "1" che indica se ogni fusibile è disabilitato o abilitato. Modifica semplicemente il codice esadecimale (`0x30` è `0` e `0x31` è `1`) per **modificare i valori dei fusibili**.
Puoi caricare questo file in [https://hexed.it/](https://hexed.it/) e cercare la stringa precedente. Dopo questa stringa puoi vedere in ASCII un numero "0" o "1" che indica se ciascun fusibile è disabilitato o abilitato. Modifica semplicemente il codice esadecimale (`0x30` è `0` e `0x31` è `1`) per **modificare i valori dei fusibili**.
<figure><img src="../../../images/image (34).png" alt=""><figcaption></figcaption></figure>
@ -147,7 +147,7 @@ Potresti abusare di questa variabile d'ambiente in un plist per mantenere la per
```
## RCE con ispezione
Secondo [**questo**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), se esegui un'applicazione Electron con flag come **`--inspect`**, **`--inspect-brk`** e **`--remote-debugging-port`**, una **porta di debug sarà aperta** così potrai connetterti ad essa (ad esempio da Chrome in `chrome://inspect`) e sarai in grado di **iniettare codice su di essa** o persino avviare nuovi processi.\
Secondo [**questo**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), se esegui un'applicazione Electron con flag come **`--inspect`**, **`--inspect-brk`** e **`--remote-debugging-port`**, un **porta di debug sarà aperta** così puoi connetterti ad essa (ad esempio da Chrome in `chrome://inspect`) e sarai in grado di **iniettare codice su di essa** o persino avviare nuovi processi.\
Ad esempio:
```bash
/Applications/Signal.app/Contents/MacOS/Signal --inspect=9229
@ -155,7 +155,7 @@ Ad esempio:
require('child_process').execSync('/System/Applications/Calculator.app/Contents/MacOS/Calculator')
```
> [!CAUTION]
> Se il fuse **`EnableNodeCliInspectArguments`** è disabilitato, l'app **ignorerà i parametri node** (come `--inspect`) quando viene avviata, a meno che la variabile di ambiente **`ELECTRON_RUN_AS_NODE`** non sia impostata, che sarà anch'essa **ignorata** se il fuse **`RunAsNode`** è disabilitato.
> Se il fuse **`EnableNodeCliInspectArguments`** è disabilitato, l'app **ignorerà i parametri node** (come `--inspect`) quando viene avviata, a meno che la variabile env **`ELECTRON_RUN_AS_NODE`** non sia impostata, che sarà anch'essa **ignorata** se il fuse **`RunAsNode`** è disabilitato.
>
> Tuttavia, puoi ancora utilizzare il **parametro electron `--remote-debugging-port=9229`**, ma il payload precedente non funzionerà per eseguire altri processi.
@ -187,17 +187,17 @@ Potresti abusare di questa variabile d'ambiente in un plist per mantenere la per
<true/>
</dict>
```
## TCC Bypass abusando di versioni precedenti
## TCC Bypass abusing Older Versions
> [!TIP]
> Il demone TCC di macOS non controlla la versione eseguita dell'applicazione. Quindi, se **non puoi iniettare codice in un'applicazione Electron** con nessuna delle tecniche precedenti, potresti scaricare una versione precedente dell'APP e iniettare codice su di essa poiché otterrà comunque i privilegi TCC (a meno che il Trust Cache non lo impedisca).
> Il demone TCC di macOS non controlla la versione eseguita dell'applicazione. Quindi, se **non puoi iniettare codice in un'applicazione Electron** con nessuna delle tecniche precedenti, puoi scaricare una versione precedente dell'APP e iniettare codice su di essa poiché otterrà comunque i privilegi TCC (a meno che il Trust Cache non lo impedisca).
## Eseguire codice non JS
## Run non JS Code
Le tecniche precedenti ti permetteranno di eseguire **codice JS all'interno del processo dell'applicazione electron**. Tuttavia, ricorda che i **processi figli vengono eseguiti sotto lo stesso profilo sandbox** dell'applicazione padre e **erediteranno i loro permessi TCC**.\
Pertanto, se desideri abusare dei diritti per accedere alla fotocamera o al microfono, ad esempio, potresti semplicemente **eseguire un altro binario dal processo**.
Pertanto, se desideri abusare dei diritti per accedere alla fotocamera o al microfono, ad esempio, puoi semplicemente **eseguire un altro binario dal processo**.
## Iniezione automatica
## Automatic Injection
Lo strumento [**electroniz3r**](https://github.com/r3ggi/electroniz3r) può essere facilmente utilizzato per **trovare applicazioni electron vulnerabili** installate e iniettare codice su di esse. Questo strumento cercherà di utilizzare la tecnica **`--inspect`**:

2
src/network-services-pentesting/113-pentesting-ident.md
View File

@ -48,7 +48,7 @@ PORT STATE SERVICE VERSION
```
### Ident-user-enum
[**Ident-user-enum**](https://github.com/pentestmonkey/ident-user-enum) è un semplice script PERL per interrogare il servizio ident (113/TCP) al fine di determinare il proprietario del processo in ascolto su ciascuna porta TCP di un sistema target. L'elenco dei nomi utente raccolti può essere utilizzato per attacchi di password guessing su altri servizi di rete. Può essere installato con `apt install ident-user-enum`.
[**Ident-user-enum**](https://github.com/pentestmonkey/ident-user-enum) è un semplice script PERL per interrogare il servizio ident (113/TCP) al fine di determinare il proprietario del processo in ascolto su ciascun porto TCP di un sistema target. L'elenco dei nomi utente raccolti può essere utilizzato per attacchi di password guessing su altri servizi di rete. Può essere installato con `apt install ident-user-enum`.
```
root@kali:/opt/local/recon/192.168.1.100# ident-user-enum 192.168.1.100 22 113 139 445
ident-user-enum v1.0 ( http://pentestmonkey.net/tools/ident-user-enum )

2
src/network-services-pentesting/1521-1522-1529-pentesting-oracle-listener.md
View File

@ -14,7 +14,7 @@ Quando si enumera Oracle, il primo passo è comunicare con il TNS-Listener che d
## Riepilogo
1. **Enumerazione della Versione**: Identificare le informazioni sulla versione per cercare vulnerabilità note.
2. **Bruteforce del TNS Listener**: A volte necessario per stabilire comunicazione.
2. **Bruteforce del Listener TNS**: A volte necessario per stabilire comunicazione.
3. **Enumerazione/Bruteforce del Nome SID**: Scoprire i nomi dei database (SID).
4. **Bruteforce delle Credenziali**: Tentare di accedere al SID scoperto.
5. **Esecuzione di Codice**: Tentare di eseguire codice sul sistema.

2
src/network-services-pentesting/1521-1522-1529-pentesting-oracle-listener/README.md
View File

@ -4,7 +4,7 @@
## Informazioni di base
Oracle database (Oracle DB) è un sistema di gestione di database relazionali (RDBMS) della Oracle Corporation (da [qui](https://www.techopedia.com/definition/8711/oracle-database)).
Il database Oracle (Oracle DB) è un sistema di gestione di database relazionali (RDBMS) della Oracle Corporation (da [qui](https://www.techopedia.com/definition/8711/oracle-database)).
Quando si enumera Oracle, il primo passo è comunicare con il TNS-Listener che di solito risiede sulla porta predefinita (1521/TCP, -potresti anche trovare listener secondari su 1522–1529-).
```

2
src/network-services-pentesting/43-pentesting-whois.md
View File

@ -28,7 +28,7 @@ Inoltre, il servizio WHOIS deve sempre utilizzare un **database** per memorizzar
- `port:43 whois`
## HackTricks Automatic Commands
## HackTricks Comandi Automatici
```
Protocol_Name: WHOIS #Protocol Abbreviation if there is one.
Port_Number: 43 #Comma separated if there is more than one.

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

@ -4,7 +4,7 @@
## Informazioni di base
Questa porta è utilizzata da **Redshift** per funzionare. È fondamentalmente una variazione di **PostgreSQL** di AWS.
Questa porta è utilizzata da **Redshift** per funzionare. È fondamentalmente una variazione di **PostgreSQL** su AWS.
Per ulteriori informazioni controlla:

10
src/network-services-pentesting/5985-5986-pentesting-winrm.md
View File

@ -20,7 +20,7 @@ Per configurare PowerShell per WinRM, il cmdlet `Enable-PSRemoting` di Microsoft
Enable-PSRemoting -Force
Set-Item wsman:\localhost\client\trustedhosts *
```
Questo approccio prevede l'aggiunta di un carattere jolly alla configurazione `trustedhosts`, un passaggio che richiede un'attenta considerazione a causa delle sue implicazioni. Si nota inoltre che potrebbe essere necessario modificare il tipo di rete da "Pubblica" a "Lavoro" sulla macchina dell'attaccante.
Questo approccio prevede l'aggiunta di un carattere jolly alla configurazione `trustedhosts`, un passaggio che richiede un'attenta considerazione a causa delle sue implicazioni. Si nota anche che potrebbe essere necessario modificare il tipo di rete da "Pubblica" a "Lavoro" sulla macchina dell'attaccante.
Inoltre, WinRM può essere **attivato remotamente** utilizzando il comando `wmic`, come dimostrato di seguito:
```powershell
@ -30,7 +30,7 @@ Questo metodo consente la configurazione remota di WinRM, migliorando la flessib
### Verifica se configurato
Per verificare la configurazione della tua macchina di attacco, il comando `Test-WSMan` viene utilizzato per controllare se il target ha WinRM configurato correttamente. Eseguendo questo comando, dovresti aspettarti di ricevere dettagli riguardanti la versione del protocollo e wsmid, indicando una configurazione riuscita. Di seguito sono riportati esempi che dimostrano l'output atteso per un target configurato rispetto a uno non configurato:
Per verificare la configurazione della tua macchina di attacco, viene utilizzato il comando `Test-WSMan` per controllare se il target ha WinRM configurato correttamente. Eseguendo questo comando, dovresti aspettarti di ricevere dettagli riguardanti la versione del protocollo e wsmid, indicando una configurazione riuscita. Di seguito sono riportati esempi che dimostrano l'output atteso per un target configurato rispetto a uno non configurato:
- Per un target che **è** configurato correttamente, l'output apparirà simile a questo:
```bash
@ -52,7 +52,7 @@ Invoke-Command -computername computer-name.domain.tld -ScriptBlock {ipconfig /al
```
![](<../images/image (151).png>)
Puoi anche **eseguire un comando della tua console PS attuale tramite** _**Invoke-Command**_. Supponiamo che tu abbia localmente una funzione chiamata _**enumeration**_ e desideri **eseguirla su un computer remoto**, puoi fare:
Puoi anche **eseguire un comando della tua attuale console PS tramite** _**Invoke-Command**_. Supponiamo che tu abbia localmente una funzione chiamata _**enumeration**_ e desideri **eseguirla su un computer remoto**, puoi fare:
```powershell
Invoke-Command -ComputerName <computername> -ScriptBLock ${function:enumeration} [-ArgumentList "arguments"]
```
@ -93,7 +93,7 @@ Per utilizzare PS Remoting e WinRM ma il computer non è configurato, puoi abili
```powershell
.\PsExec.exe \\computername -u domain\username -p password -h -d powershell.exe "enable-psremoting -force"
```
### Salvataggio e ripristino delle sessioni
### Salvataggio e Ripristino delle sessioni
Questo **non funzionerà** se la **lingua** è **vincolata** nel computer remoto.
```powershell
@ -224,7 +224,7 @@ end
- [https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-3-wmi-and-winrm/](https://blog.ropnop.com/using-credentials-to-own-windows-boxes-part-3-wmi-and-winrm/)
## Comandi Automatici HackTricks
## HackTricks Comandi Automatici
```
Protocol_Name: WinRM #Protocol Abbreviation if there is one.
Port_Number: 5985 #Comma separated if there is more than one.

6
src/network-services-pentesting/nfs-service-pentesting.md
View File

@ -6,9 +6,9 @@
**NFS** è un sistema progettato per **client/server** che consente agli utenti di accedere senza problemi ai file su una rete come se questi file fossero situati all'interno di una directory locale.
Un aspetto notevole di questo protocollo è la sua mancanza di meccanismi di **autenticazione** o **autorizzazione** integrati. Invece, l'autorizzazione si basa sulle **informazioni del file system**, con il server incaricato di tradurre accuratamente le **informazioni utente fornite dal client** nel **formato di autorizzazione** richiesto dal file system, seguendo principalmente la **sintassi UNIX**.
Un aspetto notevole di questo protocollo è la sua mancanza di **meccanismi di autenticazione** o **autorizzazione** integrati. Invece, l'autorizzazione si basa su **informazioni del file system**, con il server incaricato di tradurre accuratamente **le informazioni utente fornite dal client** nel **formato di autorizzazione** richiesto dal file system, seguendo principalmente la **sintassi UNIX**.
L'autenticazione si basa comunemente su **identificatori `UID`/`GID` UNIX e appartenenze ai gruppi**. Tuttavia, sorge una sfida a causa della potenziale discrepanza nelle **mappature `UID`/`GID`** tra client e server, lasciando poco spazio per ulteriori verifiche da parte del server. Di conseguenza, il protocollo è più adatto per l'uso all'interno di **reti fidate**, data la sua dipendenza da questo metodo di autenticazione.
L'autenticazione si basa comunemente su **identificatori `UID`/`GID` UNIX e appartenenze ai gruppi**. Tuttavia, sorge una sfida a causa della potenziale discrepanza nelle **mappature `UID`/`GID`** tra client e server, lasciando spazio a nessuna verifica aggiuntiva da parte del server. Di conseguenza, il protocollo è più adatto per l'uso all'interno di **reti fidate**, data la sua dipendenza da questo metodo di autenticazione.
**Porta predefinita**: 2049/TCP/UDP (eccetto la versione 4, richiede solo TCP o UDP).
```
@ -55,7 +55,7 @@ mount -t nfs [-o vers=2] 10.12.0.150:/backup /mnt/new_back -o nolock
```
## Permessi
Se monti una cartella che contiene **file o cartelle accessibili solo da alcuni utenti** (tramite **UID**). Puoi **creare** **localmente** un utente con quel **UID** e utilizzando quell'**utente** sarai in grado di **accedere** al file/cartella.
Se monti una cartella che contiene **file o cartelle accessibili solo da alcuni utenti** (tramite **UID**). Puoi **creare** **localmente** un utente con quel **UID** e utilizzando quel **utente** sarai in grado di **accedere** al file/cartella.
## NSFShell

10
src/network-services-pentesting/pentesting-dns.md
View File

@ -19,7 +19,7 @@ PORT STATE SERVICE REASON
- **DNS Root Servers**: Questi sono al vertice della gerarchia DNS, gestendo i domini di primo livello e intervenendo solo se i server di livello inferiore non rispondono. L'Internet Corporation for Assigned Names and Numbers (**ICANN**) supervisiona il loro funzionamento, con un conteggio globale di 13.
- **Authoritative Nameservers**: Questi server hanno l'ultima parola per le query nelle loro zone designate, offrendo risposte definitive. Se non possono fornire una risposta, la query viene escalata ai server root.
- **Non-authoritative Nameservers**: Mancando di proprietà sulle zone DNS, questi server raccolgono informazioni sui domini tramite query ad altri server.
- **Caching DNS Server**: Questo tipo di server memorizza le risposte alle query precedenti per un tempo stabilito per accelerare i tempi di risposta per le richieste future, con la durata della cache determinata dal server autorevole.
- **Caching DNS Server**: Questo tipo di server memorizza le risposte alle query precedenti per un tempo stabilito per velocizzare i tempi di risposta per le richieste future, con la durata della cache determinata dal server autorevole.
- **Forwarding Server**: Svolgendo un ruolo semplice, i server di inoltro trasmettono semplicemente le query a un altro server.
- **Resolver**: Integrati all'interno di computer o router, i resolver eseguono la risoluzione dei nomi localmente e non sono considerati autorevoli.
@ -34,7 +34,7 @@ dig version.bind CHAOS TXT @DNS
```
Inoltre, lo strumento [`fpdns`](https://github.com/kirei/fpdns) può anche identificare il server.
È anche possibile acquisire il banner anche con uno script **nmap**:
È anche possibile ottenere il banner anche con uno script **nmap**:
```
--script dns-nsid
```
@ -95,11 +95,11 @@ dnsrecon -r <IP_DNS>/24 -n <IP_DNS> #DNS reverse of all of the addresses
dnsrecon -d active.htb -a -n <IP_DNS> #Zone transfer
```
> [!NOTE]
> Se riesci a trovare sottodomini che risolvono a indirizzi IP interni, dovresti provare a eseguire un attacco di brute force DNS inverso sui NS del dominio chiedendo per quel range di IP.
> Se riesci a trovare sottodomini che risolvono a indirizzi IP interni, dovresti provare a eseguire un reverse dns BF sui NS del dominio chiedendo per quel range IP.
Un altro strumento per farlo: [https://github.com/amine7536/reverse-scan](https://github.com/amine7536/reverse-scan)
Puoi interrogare i range IP inversi su [https://bgp.he.net/net/205.166.76.0/24#\_dns](https://bgp.he.net/net/205.166.76.0/24#_dns) (questo strumento è utile anche con BGP).
Puoi interrogare i range IP inversi su [https://bgp.he.net/net/205.166.76.0/24#\_dns](https://bgp.he.net/net/205.166.76.0/24#_dns) (questo strumento è anche utile con BGP).
### DNS - Subdomains BF
```bash
@ -156,7 +156,7 @@ dig google.com A @<IP>
## Post-Exploitation
- Quando si controlla la configurazione di un server Bind, controllare la configurazione del parametro **`allow-transfer`** poiché indica chi può eseguire trasferimenti di zona e **`allow-recursion`** e **`allow-query`** poiché indicano chi può inviare richieste ricorsive e richieste ad esso.
- Quando controlli la configurazione di un server Bind, verifica la configurazione del parametro **`allow-transfer`** poiché indica chi può eseguire trasferimenti di zona e **`allow-recursion`** e **`allow-query`** poiché indicano chi può inviare richieste ricorsive e richieste ad esso.
- I seguenti sono i nomi dei file relativi a DNS che potrebbero essere interessanti da cercare all'interno delle macchine:
```
host.conf

18
src/network-services-pentesting/pentesting-ftp/README.md
View File

@ -16,11 +16,11 @@ PORT STATE SERVICE
In **Active FTP**, il **client** FTP prima **inizia** la **connessione** di controllo dalla sua porta N alla porta di comando del server FTP – porta 21. Il **client** poi **ascolta** sulla porta **N+1** e invia la porta N+1 al server FTP. Il **server** FTP poi **inizia** la **connessione** dati, dalla **sua porta M alla porta N+1** del client FTP.
Tuttavia, se il client FTP ha un firewall configurato che controlla le connessioni dati in entrata dall'esterno, allora l'Active FTP potrebbe essere un problema. E una soluzione fattibile per questo è il Passive FTP.
Tuttavia, se il client FTP ha un firewall configurato che controlla le connessioni dati in entrata dall'esterno, allora l'Active FTP potrebbe essere un problema. E, una soluzione fattibile per questo è il Passive FTP.
Nel **Passive FTP**, il client inizia la connessione di controllo dalla sua porta N alla porta 21 del server FTP. Dopo di che, 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.
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
@ -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 di doppia codifica URL `%0d%0a` (in doppia codifica URL questo è `%250d%250a`) e far sì che il **server FTP esegua azioni arbitrarie**. Una di queste possibili azioni arbitrarie è scaricare contenuti da un server controllato dall'utente, eseguire la scansione delle porte o 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 provare a comunicare con altri servizi basati su testo semplice (come http).
## Scarica tutti i file da FTP
```bash
@ -152,11 +152,11 @@ Alcuni server FTP consentono il comando PORT. Questo comando può essere utilizz
[**Scopri qui come abusare di un server FTP per scansionare le porte.**](ftp-bounce-attack.md)
Potresti anche abusare di questo comportamento per far interagire un server FTP con altri protocolli. Potresti **caricare un file contenente una richiesta HTTP** e far sì che il server FTP vulnerabile **la invii a un server HTTP arbitrario** (_magari per aggiungere un nuovo utente admin?_) o persino caricare una richiesta FTP e far sì che il server FTP vulnerabile scarichi un file da un altro server FTP.\
Potresti anche abusare di questo comportamento per far interagire un server FTP con altri protocolli. Potresti **caricare un file contenente una richiesta HTTP** e far sì che il server FTP vulnerabile **la invii a un server HTTP arbitrario** (_forse per aggiungere un nuovo utente admin?_) o persino caricare una richiesta FTP e far sì che il server FTP vulnerabile scarichi un file da un altro server FTP.\
La teoria è semplice:
1. **Carica la richiesta (all'interno di un file di testo) sul server vulnerabile.** Ricorda che se vuoi parlare con un altro server HTTP o FTP devi cambiare le righe con `0x0d 0x0a`
2. **Usa `REST X` per evitare di inviare i caratteri che non vuoi inviare** (magari per caricare la richiesta all'interno del file dove dovevi mettere un'intestazione di immagine all'inizio)
2. **Usa `REST X` per evitare di inviare i caratteri che non vuoi inviare** (forse per caricare la richiesta all'interno del file dove dovevi mettere un'intestazione di immagine all'inizio)
3. **Usa `PORT` per connetterti al server e al servizio arbitrari**
4. **Usa `RETR` per inviare la richiesta salvata al server.**
@ -168,14 +168,14 @@ La teoria è semplice:
posts.txt
{{#endfile}}
- Prova a **riempire la richiesta con dati "spazzatura" relativi al protocollo** (parlando con FTP magari solo comandi spazzatura o ripetendo l'istruzione `RETR` per ottenere il file)
- Prova a **riempire la richiesta con dati "spazzatura" relativi al protocollo** (parlando con FTP 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)
Comunque, qui hai un [vecchio esempio su come abusare di questo per far scaricare un file da un server FTP diverso.](ftp-bounce-download-2oftp-file.md)
## Vulnerabilità del server Filezilla
**FileZilla** di solito **lega** a **locale** un **servizio amministrativo** per il **FileZilla-Server** (porta 14147). Se riesci a creare un **tunnel** dalla **tua macchina** per accedere a questa porta, puoi **connetterti** ad **essa** usando una **password vuota** e **creare** un **nuovo utente** per il servizio FTP.
**FileZilla** di solito **si lega** a **locale** un **servizio amministrativo** per il **FileZilla-Server** (porta 14147). Se riesci a creare un **tunnel** dalla **tua macchina** per accedere a questa porta, puoi **connetterti** ad **essa** usando una **password vuota** e **creare** un **nuovo utente** per il servizio FTP.
## File di configurazione
```
@ -186,7 +186,7 @@ vsftpd.conf
```
### Post-Exploitation
La configurazione predefinita di vsFTPd può essere trovata in `/etc/vsftpd.conf`. Qui potresti 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`

2
src/network-services-pentesting/pentesting-imap.md
View File

@ -30,7 +30,7 @@ root@kali: telnet example.com 143
>> TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=
+ TlRMTVNTUAACAAAACgAKADgAAAAFgooCBqqVKFrKPCMAAAAAAAAAAEgASABCAAAABgOAJQAAAA9JAEkAUwAwADEAAgAKAEkASQBTADAAMQABAAoASQBJAFMAMAAxAAQACgBJAEkAUwAwADEAAwAKAEkASQBTADAAMQAHAAgAHwMI0VPy1QEAAAAA
```
Oppure **automatizza** questo con il plugin **nmap** `imap-ntlm-info.nse`
Oppure **automatizzare** questo con il plugin **nmap** `imap-ntlm-info.nse`
### [Bruteforce IMAP](../generic-hacking/brute-force.md#imap)

12
src/network-services-pentesting/pentesting-ldap.md
View File

@ -4,7 +4,7 @@
L'uso di **LDAP** (Lightweight Directory Access Protocol) è principalmente per localizzare varie entità come organizzazioni, individui e risorse come file e dispositivi all'interno delle reti, sia pubbliche che private. Offre un approccio semplificato rispetto al suo predecessore, DAP, avendo un'impronta di codice più piccola.
Le directory LDAP sono strutturate per consentire la loro distribuzione su più server, con ogni server che ospita una versione **replicata** e **sincronizzata** della directory, chiamata Directory System Agent (DSA). La responsabilità per la gestione delle richieste spetta interamente al server LDAP, che può comunicare con altri DSA secondo necessità per fornire una risposta unificata al richiedente.
Le directory LDAP sono strutturate per consentirne la distribuzione su più server, con ogni server che ospita una versione **replicata** e **sincronizzata** della directory, chiamata Directory System Agent (DSA). La responsabilità per la gestione delle richieste è interamente a carico del server LDAP, che può comunicare con altri DSA secondo necessità per fornire una risposta unificata al richiedente.
L'organizzazione della directory LDAP assomiglia a una **gerarchia ad albero, partendo dalla directory radice in cima**. Questa si ramifica in paesi, che si dividono ulteriormente in organizzazioni, e poi in unità organizzative che rappresentano varie divisioni o dipartimenti, raggiungendo infine il livello delle singole entità, comprese sia le persone che le risorse condivise come file e stampanti.
@ -98,7 +98,7 @@ ldapdomaindump <IP> [-r <IP>] -u '<domain>\<username>' -p '<password>' [--authty
## Enumerazione
### Automatica
### Automatizzata
Utilizzando questo, sarai in grado di vedere le **informazioni pubbliche** (come il nome di dominio)**:**
```bash
@ -129,7 +129,7 @@ Supported LDAP versions: 3
Naming contexts:
dc=DOMAIN,dc=DOMAIN
```
Una volta che hai il contesto di denominazione, puoi effettuare alcune query più interessanti. Questa semplice query dovrebbe mostrarti tutti gli oggetti nella directory:
Una volta che hai il contesto di denominazione, puoi fare alcune query più interessanti. Questa semplice query dovrebbe mostrarti tutti gli oggetti nella directory:
```bash
>>> connection.search(search_base='DC=DOMAIN,DC=DOMAIN', search_filter='(&(objectClass=*))', search_scope='SUBTREE', attributes='*')
True
@ -213,7 +213,7 @@ Estrai **Amministratori**:
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Administrators,CN=Builtin,DC=<1_SUBDOMAIN>,DC=<TLD>"
```
Estrai **Remote Desktop Group**:
Estrai **Gruppo Desktop Remoto**:
```bash
ldapsearch -x -H ldap://<IP> -D '<DOMAIN>\<username>' -w '<password>' -b "CN=Remote Desktop Users,CN=Builtin,DC=<1_SUBDOMAIN>,DC=<TLD>"
```
@ -278,7 +278,7 @@ done
### jxplorer
Puoi scaricare un'interfaccia grafica con server LDAP qui: [http://www.jxplorer.org/downloads/users.html](http://www.jxplorer.org/downloads/users.html)
Puoi scaricare un'interfaccia grafica con il server LDAP qui: [http://www.jxplorer.org/downloads/users.html](http://www.jxplorer.org/downloads/users.html)
Per impostazione predefinita è installato in: _/opt/jxplorer_
@ -306,7 +306,7 @@ Utilizzando `ldapsearch` puoi **autenticarti** contro **kerberos invece** di tra
## POST
Se puoi accedere ai file dove sono contenute le banche dati (potrebbero trovarsi in _/var/lib/ldap_). Puoi estrarre gli hash utilizzando:
Se puoi accedere ai file dove sono contenute le basi di dati (potrebbero trovarsi in _/var/lib/ldap_). Puoi estrarre gli hash utilizzando:
```bash
cat /var/lib/ldap/*.bdb | grep -i -a -E -o "description.*" | sort | uniq -u
```

18
src/network-services-pentesting/pentesting-mssql-microsoft-sql-server/README.md
View File

@ -16,7 +16,7 @@ Da [wikipedia](https://en.wikipedia.org/wiki/Microsoft_SQL_Server):
- **master Database**: Questo database è cruciale in quanto cattura tutti i dettagli a livello di sistema per un'istanza di SQL Server.
- **msdb Database**: SQL Server Agent utilizza questo database per gestire la pianificazione di avvisi e lavori.
- **model Database**: Funziona come un modello per ogni nuovo database sull'istanza di SQL Server, dove eventuali modifiche come dimensione, ordinamento, modello di recupero e altro sono riflesse nei database appena creati.
- **model Database**: Funziona come un modello per ogni nuovo database sull'istanza di SQL Server, dove eventuali modifiche come dimensione, ordinamento, modello di recupero e altro vengono replicate nei database appena creati.
- **Resource Database**: Un database di sola lettura che ospita oggetti di sistema forniti con SQL Server. Questi oggetti, pur essendo memorizzati fisicamente nel database Resource, sono presentati logicamente nello schema sys di ogni database.
- **tempdb Database**: Funziona come un'area di archiviazione temporanea per oggetti transitori o set di risultati intermedi.
@ -64,9 +64,9 @@ msf> use exploit/windows/mssql/mssql_payload #Uploads and execute a payload
#Add new admin user from meterpreter session
msf> use windows/manage/mssql_local_auth_bypass
```
### [**Forza bruta**](../../generic-hacking/brute-force.md#sql-server)
### [**Brute force**](../../generic-hacking/brute-force.md#sql-server)
### Enumerazione manuale
### Enumerazione Manuale
#### Accesso
@ -372,7 +372,7 @@ Per **ulteriori esempi** controlla la [**fonte originale**](https://blog.waynesh
È possibile **caricare un .NET dll all'interno di MSSQL con funzioni personalizzate**. Questo, tuttavia, **richiede accesso `dbo`** quindi hai bisogno di una connessione al database **come `sa` o un ruolo di Amministratore**.
[**Segui questo link**](../../pentesting-web/sql-injection/mssql-injection.md#mssql-user-defined-function-sqlhttp) per vedere un esempio.
[**Seguendo questo link**](../../pentesting-web/sql-injection/mssql-injection.md#mssql-user-defined-function-sqlhttp) per vedere un esempio.
### RCE con `autoadmin_task_agents`
@ -476,13 +476,13 @@ Puoi utilizzare un modulo **metasploit**:
```bash
msf> use auxiliary/admin/mssql/mssql_escalate_dbowner
```
O uno script **PS**:
O un **script PS**:
```powershell
# https://raw.githubusercontent.com/nullbind/Powershellery/master/Stable-ish/MSSQL/Invoke-SqlServer-Escalate-Dbowner.psm1
Import-Module .Invoke-SqlServerDbElevateDbOwner.psm1
Invoke-SqlServerDbElevateDbOwner -SqlUser myappuser -SqlPass MyPassword! -SqlServerInstance 10.2.2.184
```
### Impersonificazione di altri utenti
### Impersonazione di altri utenti
SQL Server ha un permesso speciale, chiamato **`IMPERSONATE`**, che **consente all'utente che esegue di assumere i permessi di un altro utente** o login fino a quando il contesto non viene ripristinato o la sessione termina.
```sql
@ -507,7 +507,7 @@ use_link [NAME]
> [!NOTE]
> Se puoi impersonare un utente, anche se non è sysadmin, dovresti controllare se l'utente ha accesso ad altri database o server collegati.
Nota che una volta che sei sysadmin puoi impersonare qualsiasi altro utente:
Nota che una volta che sei sysadmin puoi impersonare qualsiasi altro:
```sql
-- Impersonate RegUser
EXECUTE AS LOGIN = 'RegUser'
@ -537,7 +537,7 @@ Un attaccante può estrarre le password dei Linked Servers di SQL Server dalle i
Alcuni requisiti e configurazioni devono essere eseguiti affinché questo exploit funzioni. Prima di tutto, è necessario avere diritti di Amministratore sulla macchina, o la capacità di gestire le Configurazioni di SQL Server.
Dopo aver convalidato i tuoi permessi, devi configurare tre cose, che sono le seguenti:
Dopo aver convalidato le tue autorizzazioni, è necessario configurare tre cose, che sono le seguenti:
1. Abilitare TCP/IP sulle istanze di SQL Server;
2. Aggiungere un parametro di avvio, in questo caso, verrà aggiunto un flag di traccia, che è -T7806.
@ -545,7 +545,7 @@ Dopo aver convalidato i tuoi permessi, devi configurare tre cose, che sono le se
Per automatizzare queste configurazioni, [questo repository](https://github.com/IamLeandrooooo/SQLServerLinkedServersPasswords/) ha gli script necessari. Oltre ad avere uno script powershell per ciascun passaggio della configurazione, il repository ha anche uno script completo che combina gli script di configurazione e l'estrazione e decrittografia delle password.
Per ulteriori informazioni, fai riferimento ai seguenti link riguardanti questo attacco: [Decrittografia delle password del server di collegamento del database MSSQL](https://www.netspi.com/blog/technical/adversary-simulation/decrypting-mssql-database-link-server-passwords/)
Per ulteriori informazioni, fare riferimento ai seguenti link riguardanti questo attacco: [Decrittografare le password dei Linked Server di MSSQL](https://www.netspi.com/blog/technical/adversary-simulation/decrypting-mssql-database-link-server-passwords/)
[Risoluzione dei problemi della connessione dedicata per l'amministratore di SQL Server](https://www.mssqltips.com/sqlservertip/5364/troubleshooting-the-sql-server-dedicated-administrator-connection/)

8
src/network-services-pentesting/pentesting-mysql.md
View File

@ -4,7 +4,7 @@
## **Informazioni di base**
**MySQL** può essere descritto come un **Sistema di Gestione di Database Relazionali (RDBMS)** open source disponibile gratuitamente. Funziona con il **Linguaggio di Query Strutturato (SQL)**, consentendo la gestione e la manipolazione dei database.
**MySQL** può essere descritto come un **Sistema di Gestione di Database Relazionali (RDBMS)** open source disponibile gratuitamente. Funziona sul **Linguaggio di Query Strutturato (SQL)**, consentendo la gestione e la manipolazione dei database.
**Porta predefinita:** 3306
```
@ -109,9 +109,9 @@ Puoi vedere nella documentazione il significato di ciascun privilegio: [https://
../pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md
{{#endref}}
## Lettura arbitraria di file MySQL da parte del client
## MySQL lettura arbitraria di file da parte del client
In realtà, quando provi a **caricare dati locali in una tabella** il **contenuto di un file**, il server MySQL o MariaDB chiede al **client di leggerlo** e inviare il contenuto. **Quindi, se riesci a manomettere un client mysql per connetterti al tuo server MySQL, puoi leggere file arbitrari.**\
In realtà, quando provi a **caricare dati locali in una tabella** il **contenuto di un file** il server MySQL o MariaDB chiede al **client di leggerlo** e inviare il contenuto. **Quindi, se riesci a manomettere un client mysql per connetterti al tuo server MySQL, puoi leggere file arbitrari.**\
Si prega di notare che questo è il comportamento utilizzando:
```bash
load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
@ -144,7 +144,7 @@ systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '=
Nella configurazione dei servizi MySQL, vengono impiegate varie impostazioni per definire il suo funzionamento e le misure di sicurezza:
- L'impostazione **`user`** è utilizzata per designare l'utente sotto il quale verrà eseguito il servizio MySQL.
- L'impostazione **`user`** è utilizzata per designare l'utente sotto il quale il servizio MySQL verrà eseguito.
- **`password`** è applicata per stabilire la password associata all'utente MySQL.
- **`admin_address`** specifica l'indirizzo IP che ascolta le connessioni TCP/IP sull'interfaccia di rete amministrativa.
- La variabile **`debug`** è indicativa delle attuali configurazioni di debug, inclusa l'informazione sensibile all'interno dei log.

4
src/network-services-pentesting/pentesting-ntp.md
View File

@ -40,9 +40,9 @@ nmap -sU -sV --script "ntp* and (discovery or vuln) and not (dos or brute)" -p 1
## Attacco di Amplificazione NTP
[**Come Funziona l'Attacco DDoS NTP**](https://resources.infosecinstitute.com/network-time-protocol-ntp-threats-countermeasures/#gref)
[**Come funziona l'attacco DDoS NTP**](https://resources.infosecinstitute.com/network-time-protocol-ntp-threats-countermeasures/#gref)
Il **protocollo NTP**, utilizzando UDP, consente il funzionamento senza la necessità di procedure di handshake, a differenza di TCP. Questa caratteristica viene sfruttata negli **attacchi di amplificazione DDoS NTP**. Qui, gli attaccanti creano pacchetti con un IP sorgente falso, facendo sembrare che le richieste di attacco provengano dalla vittima. Questi pacchetti, inizialmente piccoli, inducono il server NTP a rispondere con volumi di dati molto più grandi, amplificando l'attacco.
Il **protocollo NTP**, che utilizza UDP, consente il funzionamento senza la necessità di procedure di handshake, a differenza di TCP. Questa caratteristica viene sfruttata negli **attacchi di amplificazione DDoS NTP**. Qui, gli attaccanti creano pacchetti con un IP sorgente falso, facendo sembrare che le richieste di attacco provengano dalla vittima. Questi pacchetti, inizialmente piccoli, inducono il server NTP a rispondere con volumi di dati molto più grandi, amplificando l'attacco.
Il comando _**MONLIST**_, nonostante il suo uso raro, può segnalare gli ultimi 600 client connessi al servizio NTP. Sebbene il comando stesso sia semplice, il suo uso improprio in tali attacchi evidenzia vulnerabilità critiche nella sicurezza.
```bash

4
src/network-services-pentesting/pentesting-pop.md
View File

@ -13,14 +13,14 @@ PORT STATE SERVICE
```
## Enumerazione
### Acquisizione del Banner
### Acquisizione Banner
```bash
nc -nv <IP> 110
openssl s_client -connect <IP>:995 -crlf -quiet
```
## Manuale
Puoi utilizzare il comando `CAPA` per ottenere le capacità del server POP3.
Puoi usare il comando `CAPA` per ottenere le capacità del server POP3.
## Automatizzato
```bash

8
src/network-services-pentesting/pentesting-rpcbind.md
View File

@ -54,8 +54,8 @@ ypcat –d <domain-name> –h <server-ip> passwd.byname
| **Master file** | **Map(s)** | **Notes** |
| ---------------- | --------------------------- | --------------------------------- |
| /etc/hosts | hosts.byname, hosts.byaddr | Contiene nomi host e dettagli IP |
| /etc/passwd | passwd.byname, passwd.byuid | File delle password utente NIS |
| /etc/group | group.byname, group.bygid | File dei gruppi NIS |
| /etc/passwd | passwd.byname, passwd.byuid | File password utente NIS |
| /etc/group | group.byname, group.bygid | File gruppo NIS |
| /usr/lib/aliases | mail.aliases | Dettagli sugli alias di posta |
## RPC Users
@ -64,11 +64,11 @@ Se trovi il servizio **rusersd** elencato in questo modo:
![](<../images/image (1041).png>)
Potresti enumerare gli utenti della macchina. Per sapere come leggi [1026 - Pentesting Rsusersd](1026-pentesting-rusersd.md).
Puoi enumerare gli utenti della macchina. Per sapere come, leggi [1026 - Pentesting Rsusersd](1026-pentesting-rusersd.md).
## Bypass Filtered Portmapper port
Quando si esegue una **scansione nmap** e si scoprono porte NFS aperte con la porta 111 filtrata, l'esploitazione diretta di queste porte non è fattibile. Tuttavia, simulando un servizio portmapper localmente e creando un tunnel dalla tua macchina al bersaglio, l'esploitazione diventa possibile utilizzando strumenti standard. Questa tecnica consente di bypassare lo stato filtrato della porta 111, abilitando così l'accesso ai servizi NFS. Per una guida dettagliata su questo metodo, fai riferimento all'articolo disponibile a [questo link](https://medium.com/@sebnemK/how-to-bypass-filtered-portmapper-port-111-27cee52416bc).
Quando esegui una **scansione nmap** e scopri porte NFS aperte con la porta 111 filtrata, l'esploitazione diretta di queste porte non è fattibile. Tuttavia, simulando un servizio portmapper localmente e creando un tunnel dalla tua macchina al bersaglio, l'esploitazione diventa possibile utilizzando strumenti standard. Questa tecnica consente di bypassare lo stato filtrato della porta 111, abilitando così l'accesso ai servizi NFS. Per una guida dettagliata su questo metodo, fai riferimento all'articolo disponibile a [questo link](https://medium.com/@sebnemK/how-to-bypass-filtered-portmapper-port-111-27cee52416bc).
## Shodan

22
src/network-services-pentesting/pentesting-smb.md
View File

@ -2,15 +2,15 @@
{{#include ../banners/hacktricks-training.md}}
## **Porta 139**
## **Port 139**
Il _**Network Basic Input Output System**_** (NetBIOS)** è un protocollo software progettato per consentire a applicazioni, PC e desktop all'interno di una rete locale (LAN) di interagire con l'hardware di rete e **facilitare la trasmissione di dati attraverso la rete**. L'identificazione e la localizzazione delle applicazioni software che operano su una rete NetBIOS avvengono attraverso i loro nomi NetBIOS, che possono avere una lunghezza massima di 16 caratteri e sono spesso distinti dal nome del computer. Una sessione NetBIOS tra due applicazioni viene avviata quando un'applicazione (che funge da client) emette un comando per "chiamare" un'altra applicazione (che funge da server) utilizzando **TCP Port 139**.
Il _**Network Basic Input Output System**_** (NetBIOS)** è un protocollo software progettato per consentire ad applicazioni, PC e desktop all'interno di una rete locale (LAN) di interagire con l'hardware di rete e **facilitare la trasmissione di dati attraverso la rete**. L'identificazione e la localizzazione delle applicazioni software che operano su una rete NetBIOS avvengono attraverso i loro nomi NetBIOS, che possono avere una lunghezza massima di 16 caratteri e sono spesso distinti dal nome del computer. Una sessione NetBIOS tra due applicazioni viene avviata quando un'applicazione (che funge da client) emette un comando per "chiamare" un'altra applicazione (che funge da server) utilizzando **TCP Port 139**.
```
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
```
## Port 445
Tecnicamente, la porta 139 è riferita come ‘NBT over IP’, mentre la porta 445 è identificata come ‘SMB over IP’. L'acronimo **SMB** sta per ‘**Server Message Blocks**’, che è anche modernamente conosciuto come il **Common Internet File System (CIFS)**. Come protocollo di rete a livello applicativo, SMB/CIFS è principalmente utilizzato per abilitare l'accesso condiviso a file, stampanti, porte seriali e facilitare varie forme di comunicazione tra nodi su una rete.
Tecnicamente, la Porta 139 è riferita come ‘NBT over IP’, mentre la Porta 445 è identificata come ‘SMB over IP’. L'acronimo **SMB** sta per ‘**Server Message Blocks**’, che è anche modernamente conosciuto come il **Common Internet File System (CIFS)**. Come protocollo di rete a livello applicativo, SMB/CIFS è principalmente utilizzato per abilitare l'accesso condiviso a file, stampanti, porte seriali e facilitare varie forme di comunicazione tra nodi su una rete.
Ad esempio, nel contesto di Windows, si evidenzia che SMB può operare direttamente su TCP/IP, eliminando la necessità di NetBIOS su TCP/IP, attraverso l'utilizzo della porta 445. Al contrario, su sistemi diversi, si osserva l'impiego della porta 139, indicando che SMB viene eseguito in congiunzione con NetBIOS su TCP/IP.
```
@ -18,7 +18,7 @@ Ad esempio, nel contesto di Windows, si evidenzia che SMB può operare direttame
```
### SMB
Il **Server Message Block (SMB)** protocol, che opera in un modello **client-server**, è progettato per regolare l'**accesso ai file**, alle directory e ad altre risorse di rete come stampanti e router. Utilizzato principalmente all'interno della serie di sistemi operativi **Windows**, SMB garantisce la compatibilità all'indietro, consentendo ai dispositivi con versioni più recenti del sistema operativo Microsoft di interagire senza problemi con quelli che eseguono versioni più vecchie. Inoltre, il progetto **Samba** offre una soluzione software gratuita, consentendo l'implementazione di SMB su sistemi **Linux** e Unix, facilitando così la comunicazione cross-platform tramite SMB.
Il **Server Message Block (SMB)** protocol, che opera in un modello **client-server**, è progettato per regolare l'**accesso ai file**, alle directory e ad altre risorse di rete come stampanti e router. Utilizzato principalmente all'interno della serie di sistemi operativi **Windows**, SMB garantisce la compatibilità all'indietro, consentendo ai dispositivi con versioni più recenti del sistema operativo di Microsoft di interagire senza problemi con quelli che eseguono versioni più vecchie. Inoltre, il progetto **Samba** offre una soluzione software gratuita, consentendo l'implementazione di SMB su sistemi **Linux** e Unix, facilitando così la comunicazione cross-platform tramite SMB.
Le condivisioni, che rappresentano **parti arbitrarie del file system locale**, possono essere fornite da un server SMB, rendendo la gerarchia visibile a un client in parte **indipendente** dalla struttura effettiva del server. Le **Access Control Lists (ACLs)**, che definiscono i **diritti di accesso**, consentono un **controllo dettagliato** sulle autorizzazioni degli utenti, inclusi attributi come **`execute`**, **`read`** e **`full access`**. Queste autorizzazioni possono essere assegnate a singoli utenti o gruppi, in base alle condivisioni, e sono distinte dalle autorizzazioni locali impostate sul server.
@ -197,7 +197,7 @@ smbmap -u "username" -p "<NT>:<LM>" [-r/-R] [Folder] -H <IP> [-P <PORT>] #Pass-t
```
### **Enumerare manualmente le condivisioni di Windows e connettersi ad esse**
Potrebbe essere possibile che tu sia limitato nella visualizzazione delle condivisioni della macchina host e quando provi a elencarle sembra che non ci siano condivisioni a cui connettersi. Pertanto, potrebbe valere la pena provare a connettersi manualmente a una condivisione. Per enumerare manualmente le condivisioni, potresti voler cercare risposte come NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME, quando utilizzi una sessione valida (ad es. sessione nulla o credenziali valide). Questi possono indicare se la condivisione esiste e non hai accesso ad essa o se la condivisione non esiste affatto.
Potrebbe essere possibile che tu sia limitato nella visualizzazione delle condivisioni della macchina host e quando provi a elencarle sembra che non ci siano condivisioni a cui connettersi. Pertanto, potrebbe valere la pena provare a connettersi manualmente a una condivisione. Per enumerare manualmente le condivisioni, potresti voler cercare risposte come NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME, quando utilizzi una sessione valida (ad es. sessione nulla o credenziali valide). Queste possono indicare se la condivisione esiste e non hai accesso ad essa o se la condivisione non esiste affatto.
I nomi di condivisione comuni per i target Windows sono
@ -239,7 +239,7 @@ esempi
smbclient -U '%' -N \\\\192.168.0.24\\im_clearly_not_here # returns NT_STATUS_BAD_NETWORK_NAME
smbclient -U '%' -N \\\\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED or even gives you a session
```
### **Enumerare le condivisioni da Windows / senza strumenti di terze parti**
### **Enumerare condivisioni da Windows / senza strumenti di terze parti**
PowerShell
```powershell
@ -267,7 +267,7 @@ compmgmt.msc
```
explorer.exe (grafico), inserisci `\\<ip>\` per vedere le condivisioni disponibili non nascoste.
### Monta una cartella condivisa
### Montare una cartella condivisa
```bash
mount -t cifs //x.x.x.x/share /mnt/share
mount -t cifs -o "username=user,password=password" //x.x.x.x/share /mnt/share
@ -330,7 +330,7 @@ La **configurazione predefinita di** un **server Samba** si trova solitamente in
| **Impostazione** | **Descrizione** |
| --------------------------- | ----------------------------------------------------------------- |
| `browseable = yes` | Consentire l'elenco delle condivisioni disponibili nella condivisione attuale? |
| `browseable = yes` | Consentire l'elenco delle condivisioni disponibili nella condivisione corrente? |
| `read only = no` | Vietare la creazione e la modifica di file? |
| `writable = yes` | Consentire agli utenti di creare e modificare file? |
| `guest ok = yes` | Consentire la connessione al servizio senza utilizzare una password? |
@ -354,7 +354,7 @@ rpcclient -k ws01win10.domain.com
### **crackmapexec**
crackmapexec può eseguire comandi **abusando** di qualsiasi **mmcexec, smbexec, atexec, wmiexec**, essendo **wmiexec** il **metodo** **predefinito**. Puoi indicare quale opzione preferisci utilizzare con il parametro `--exec-method`:
crackmapexec può eseguire comandi **abusando** di qualsiasi **mmcexec, smbexec, atexec, wmiexec**, essendo **wmiexec** il metodo **predefinito**. Puoi indicare quale opzione preferisci utilizzare con il parametro `--exec-method`:
```bash
apt-get install crackmapexec
@ -409,7 +409,7 @@ Utilizzando **parameter**`-k` puoi autenticarti contro **kerberos** invece di **
```
### [AtExec](../windows-hardening/ntlm/atexec.md)
Esegui comandi tramite il Task Scheduler (utilizzando _\pipe\atsvc_ tramite SMB).\
Eseguire comandi tramite il Task Scheduler (utilizzando _\pipe\atsvc_ tramite SMB).\
In **kali** si trova in /usr/share/doc/python3-impacket/examples/
```bash
./atexec.py [[domain/]username[:password]@]<targetName or address> "command"
@ -454,7 +454,7 @@ Che sono utilizzate da alcuni browser e strumenti (come Skype)
Simile al SMB Trapping, piantare file dannosi su un sistema target (via SMB, ad esempio) può provocare un tentativo di autenticazione SMB, consentendo di intercettare l'hash NetNTLMv2 con uno strumento come Responder. L'hash può quindi essere decifrato offline o utilizzato in un [attacco di relay SMB](pentesting-smb.md#smb-relay-attack).
[Vedi: ntlm_theft](../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
[Guarda: ntlm_theft](../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
## Comandi automatici HackTricks
```

40
src/network-services-pentesting/pentesting-smb/README.md
View File

@ -4,7 +4,7 @@
## **Porta 139**
Il _**Network Basic Input Output System**_\*\* (NetBIOS)\*\* è un protocollo software progettato per consentire ad applicazioni, PC e desktop all'interno di una rete locale (LAN) di interagire con l'hardware di rete e **facilitare la trasmissione di dati attraverso la rete**. L'identificazione e la localizzazione delle applicazioni software che operano su una rete NetBIOS avvengono attraverso i loro nomi NetBIOS, che possono avere una lunghezza massima di 16 caratteri e sono spesso distinti dal nome del computer. Una sessione NetBIOS tra due applicazioni viene avviata quando un'applicazione (che funge da client) emette un comando per "chiamare" un'altra applicazione (che funge da server) utilizzando **TCP Port 139**.
Il _**Network Basic Input Output System**_\*\* (NetBIOS)\*\* è un protocollo software progettato per consentire alle applicazioni, PC e Desktop all'interno di una rete locale (LAN) di interagire con l'hardware di rete e **facilitare la trasmissione di dati attraverso la rete**. L'identificazione e la localizzazione delle applicazioni software che operano su una rete NetBIOS avvengono attraverso i loro nomi NetBIOS, che possono avere una lunghezza massima di 16 caratteri e sono spesso distinti dal nome del computer. Una sessione NetBIOS tra due applicazioni viene avviata quando un'applicazione (che funge da client) emette un comando per "chiamare" un'altra applicazione (che funge da server) utilizzando **TCP Port 139**.
```
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
```
@ -18,9 +18,9 @@ Ad esempio, nel contesto di Windows, si evidenzia che SMB può operare direttame
```
### SMB
Il **Server Message Block (SMB)** protocol, che opera in un modello **client-server**, è progettato per regolare l'**accesso ai file**, alle directory e ad altre risorse di rete come stampanti e router. Utilizzato principalmente all'interno della serie di sistemi operativi **Windows**, SMB garantisce la compatibilità all'indietro, consentendo ai dispositivi con versioni più recenti del sistema operativo Microsoft di interagire senza problemi con quelli che eseguono versioni più vecchie. Inoltre, il progetto **Samba** offre una soluzione software gratuita, consentendo l'implementazione di SMB su sistemi **Linux** e Unix, facilitando così la comunicazione cross-platform tramite SMB.
Il **Server Message Block (SMB)** protocollo, che opera in un modello **client-server**, è progettato per regolare l'**accesso ai file**, alle directory e ad altre risorse di rete come stampanti e router. Utilizzato principalmente all'interno della serie di sistemi operativi **Windows**, SMB garantisce la compatibilità all'indietro, consentendo ai dispositivi con versioni più recenti del sistema operativo Microsoft di interagire senza problemi con quelli che eseguono versioni più vecchie. Inoltre, il progetto **Samba** offre una soluzione software gratuita, consentendo l'implementazione di SMB su sistemi **Linux** e Unix, facilitando così la comunicazione cross-platform tramite SMB.
Le condivisioni, che rappresentano **parti arbitrarie del file system locale**, possono essere fornite da un server SMB, rendendo la gerarchia visibile a un client in parte **indipendente** dalla struttura effettiva del server. Le **Access Control Lists (ACLs)**, che definiscono i **diritti di accesso**, consentono un **controllo dettagliato** sui permessi degli utenti, inclusi attributi come **`execute`**, **`read`** e **`full access`**. Questi permessi possono essere assegnati a singoli utenti o gruppi, in base alle condivisioni, e sono distinti dai permessi locali impostati sul server.
Le condivisioni, che rappresentano **parti arbitrarie del file system locale**, possono essere fornite da un server SMB, rendendo la gerarchia visibile a un client in parte **indipendente** dalla struttura effettiva del server. Le **Access Control Lists (ACLs)**, che definiscono i **diritti di accesso**, consentono un **controllo dettagliato** sulle autorizzazioni degli utenti, inclusi attributi come **`execute`**, **`read`** e **`full access`**. Queste autorizzazioni possono essere assegnate a singoli utenti o gruppi, in base alle condivisioni, e sono distinte dalle autorizzazioni locali impostate sul server.
### IPC$ Share
@ -161,7 +161,7 @@ rpcclient-enumeration.md
`xdg-open smb://cascade.htb/`
#### Nella finestra del browser di file (nautilus, thunar, ecc)
#### Nella finestra del file browser (nautilus, thunar, ecc)
`smb://friendzone.htb/general/`
@ -197,7 +197,7 @@ smbmap -u "username" -p "<NT>:<LM>" [-r/-R] [Folder] -H <IP> [-P <PORT>] #Pass-t
```
### **Enumerare manualmente le condivisioni di Windows e connettersi ad esse**
Potrebbe essere possibile che tu sia limitato nella visualizzazione delle condivisioni della macchina host e quando provi a elencarle sembra che non ci siano condivisioni a cui connettersi. Pertanto, potrebbe valere la pena provare a connettersi manualmente a una condivisione. Per enumerare manualmente le condivisioni, potresti voler cercare risposte come NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME, quando utilizzi una sessione valida (ad es. sessione nulla o credenziali valide). Questi possono indicare se la condivisione esiste e non hai accesso ad essa o se la condivisione non esiste affatto.
Potrebbe essere possibile che tu sia limitato nella visualizzazione delle condivisioni della macchina host e quando provi a elencarle sembra che non ci siano condivisioni a cui connettersi. Pertanto, potrebbe valere la pena provare a connettersi manualmente a una condivisione. Per enumerare manualmente le condivisioni, potresti voler cercare risposte come NT_STATUS_ACCESS_DENIED e NT_STATUS_BAD_NETWORK_NAME, quando utilizzi una sessione valida (ad es. sessione nulla o credenziali valide). Queste possono indicare se la condivisione esiste e non hai accesso ad essa o se la condivisione non esiste affatto.
I nomi di condivisione comuni per i target Windows sono
@ -272,7 +272,7 @@ explorer.exe (grafico), inserisci `\\<ip>\` per vedere le condivisioni disponibi
mount -t cifs //x.x.x.x/share /mnt/share
mount -t cifs -o "username=user,password=password" //x.x.x.x/share /mnt/share
```
### **Scarica file**
### **Scarica i file**
Leggi le sezioni precedenti per imparare come connetterti con credenziali/Pass-the-Hash.
```bash
@ -313,7 +313,7 @@ sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'De
Particolarmente interessanti tra le condivisioni sono i file chiamati **`Registry.xml`** poiché **possono contenere password** per gli utenti configurati con **autologon** tramite Group Policy. Oppure i file **`web.config`** poiché contengono credenziali.
> [!NOTE]
> La **condivisione SYSVOL** è **leggibile** da tutti gli utenti autenticati nel dominio. Lì puoi **trovare** molti diversi batch, VBScript e **script** PowerShell.\
> La **condivisione SYSVOL** è **leggibile** da tutti gli utenti autenticati nel dominio. Lì puoi **trovare** molti diversi **script** batch, VBScript e PowerShell.\
> Dovresti **controllare** gli **script** al suo interno poiché potresti **trovare** informazioni sensibili come **password**.
## Leggi il Registro
@ -329,17 +329,17 @@ sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a87
La **configurazione predefinita di** un **server Samba** si trova solitamente in `/etc/samba/smb.conf` e potrebbe avere alcune **configurazioni pericolose**:
| **Impostazione** | **Descrizione** |
| --------------------------- | ----------------------------------------------------------------- |
| `browseable = yes` | Consentire l'elenco delle condivisioni disponibili nella condivisione attuale? |
| --------------------------- | ------------------------------------------------------------------ |
| `browseable = yes` | Consentire l'elenco delle condivisioni disponibili nella condivisione corrente? |
| `read only = no` | Vietare la creazione e la modifica di file? |
| `writable = yes` | Consentire agli utenti di creare e modificare file? |
| `guest ok = yes` | Consentire la connessione al servizio senza utilizzare una password? |
| `enable privileges = yes` | Rispettare i privilegi assegnati a SID specifici? |
| `create mask = 0777` | Quali permessi devono essere assegnati ai file appena creati? |
| `create mask = 0777` | Quali permessi devono essere assegnati ai file appena creati? |
| `directory mask = 0777` | Quali permessi devono essere assegnati alle directory appena create? |
| `logon script = script.sh` | Quale script deve essere eseguito al login dell'utente? |
| `logon script = script.sh` | Quale script deve essere eseguito al login dell'utente? |
| `magic script = script.sh` | Quale script dovrebbe essere eseguito quando lo script viene chiuso? |
| `magic output = script.out` | Dove deve essere memorizzato l'output dello script magico? |
| `magic output = script.out` | Dove deve essere memorizzato l'output dello script magico? |
Il comando `smbstatus` fornisce informazioni sul **server** e su **chi è connesso**.
@ -379,7 +379,7 @@ crackmapexec smb <IP> -d <DOMAIN> -u Administrator -H <HASH> #Pass-The-Hash
### [**psexec**](../../windows-hardening/lateral-movement/psexec-and-winexec.md)**/**[**smbexec**](../../windows-hardening/lateral-movement/smbexec.md)
Entrambe le opzioni **creeranno un nuovo servizio** (utilizzando _\pipe\svcctl_ tramite SMB) nella macchina vittima e lo utilizzeranno per **eseguire qualcosa** (**psexec** **caricherà** un file eseguibile nella condivisione ADMIN$ e **smbexec** punterà a **cmd.exe/powershell.exe** e metterà negli argomenti il payload --**tecnica senza file-**-).\
**Maggiore info** su [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md)e [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
**Ulteriori informazioni** su [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md)e [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
In **kali** si trova in /usr/share/doc/python3-impacket/examples/
```bash
#If no password is provided, it will be prompted
@ -426,9 +426,9 @@ In **kali** si trova in /usr/share/doc/python3-impacket/examples/
nmap --script smb-brute -p 445 <IP>
ridenum.py <IP> 500 50000 /root/passwds.txt #Get usernames bruteforcing that rids and then try to bruteforce each user name
```
## Attacco di relay SMB
## SMB relay attack
Questo attacco utilizza il toolkit Responder per **catturare le sessioni di autenticazione SMB** su una rete interna e **relevarle** a una **macchina target**. Se la **sessione di autenticazione ha successo**, ti porterà automaticamente in una **shell** **di sistema**.\
Questo attacco utilizza il toolkit Responder per **catturare le sessioni di autenticazione SMB** su una rete interna e **rilanciarle** a una **macchina target**. Se la **sessione di autenticazione ha successo**, ti porterà automaticamente in una **shell** **di sistema**.\
[**Ulteriori informazioni su questo attacco qui.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
## SMB-Trap
@ -446,17 +446,17 @@ Che sono utilizzate da alcuni browser e strumenti (come Skype)
![Da: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>)
### SMBTrap utilizzando MitMf
### SMBTrap usando MitMf
![Da: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (892).png>)
## Furto NTLM
## NTLM Theft
Simile al SMB Trapping, piantare file dannosi su un sistema target (via SMB, ad esempio) può innescare un tentativo di autenticazione SMB, consentendo di intercettare l'hash NetNTLMv2 con uno strumento come Responder. L'hash può quindi essere decifrato offline o utilizzato in un [attacco di relay SMB](#smb-relay-attack).
Simile al SMB Trapping, piantare file dannosi su un sistema target (via SMB, ad esempio) può provocare un tentativo di autenticazione SMB, consentendo di intercettare l'hash NetNTLMv2 con uno strumento come Responder. L'hash può quindi essere decifrato offline o utilizzato in un [SMB relay attack](#smb-relay-attack).
[Vedi: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
[See: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
## Comandi automatici HackTricks
## HackTricks Automatic Commands
```
Protocol_Name: SMB #Protocol Abbreviation if there is one.
Port_Number: 137,138,139 #Comma separated if there is more than one.

50
src/network-services-pentesting/pentesting-smtp/README.md
View File

@ -19,7 +19,7 @@ Se hai l'opportunità di **far inviare alla vittima un'email** (ad esempio trami
Puoi anche ottenere un'email da un server SMTP cercando di **inviare a quel server un'email a un indirizzo inesistente** (perché il server invierà all'attaccante un'email NDN). Ma assicurati di inviare l'email da un indirizzo consentito (controlla la politica SPF) e che tu possa ricevere messaggi NDN.
Dovresti anche provare a **inviare contenuti diversi perché potresti trovare informazioni più interessanti** nelle intestazioni come: `X-Virus-Scanned: by av.domain.com`\
Dovresti anche cercare di **inviare contenuti diversi perché potresti trovare informazioni più interessanti** nelle intestazioni come: `X-Virus-Scanned: by av.domain.com`\
Dovresti inviare il file di test EICAR.\
Rilevare l'**AV** potrebbe consentirti di sfruttare **vulnerabilità note.**
@ -150,7 +150,7 @@ Nmap: nmap --script smtp-enum-users <IP>
```
## DSN Reports
**Rapporti di Notifica dello Stato di Consegna**: Se invii un **email** a un'organizzazione a un **indirizzo non valido**, l'organizzazione ti notificherà che l'indirizzo era invalido inviando una **mail di ritorno**. Le **intestazioni** dell'email restituita conterranno possibili **informazioni sensibili** (come l'indirizzo IP dei servizi di posta che hanno interagito con i rapporti o informazioni sul software antivirus).
**Rapporti di Notifica dello Stato di Consegna**: Se invii un **email** a un'organizzazione a un **indirizzo non valido**, l'organizzazione ti notificherà che l'indirizzo era invalido inviando un **messaggio di ritorno**. Gli **header** dell'email restituita conterranno possibili **informazioni sensibili** (come l'indirizzo IP dei servizi email che hanno interagito con i rapporti o informazioni sul software antivirus).
## [Commands](smtp-commands.md)
@ -235,7 +235,7 @@ Una **guida completa a queste contromisure** è disponibile su [https://seantheg
> [!CAUTION]
> SPF [è stato "deprecato" nel 2014](https://aws.amazon.com/premiumsupport/knowledge-center/route53-spf-record/). Questo significa che invece di creare un **record TXT** in `_spf.domain.com` lo crei in `domain.com` utilizzando la **stessa sintassi**.\
> Inoltre, per riutilizzare i record spf precedenti è abbastanza comune trovare qualcosa come `"v=spf1 include:_spf.google.com ~all"`
> Inoltre, per riutilizzare i record SPF precedenti è abbastanza comune trovare qualcosa come `"v=spf1 include:_spf.google.com ~all"`
**Sender Policy Framework** (SPF) è un meccanismo che consente ai Mail Transfer Agents (MTAs) di verificare se un host che invia un'email è autorizzato interrogando un elenco di server di posta autorizzati definiti dalle organizzazioni. Questo elenco, che specifica indirizzi/range IP, domini e altre entità **autorizzate a inviare email per conto di un nome di dominio**, include vari "**Meccanismi**" nel record SPF.
@ -244,18 +244,18 @@ Una **guida completa a queste contromisure** è disponibile su [https://seantheg
Da [Wikipedia](https://en.wikipedia.org/wiki/Sender_Policy_Framework):
| Meccanismo | Descrizione |
| ----------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ALL | Corrisponde sempre; utilizzato per un risultato predefinito come `-all` per tutti gli IP non corrispondenti ai meccanismi precedenti. |
| A | Se il nome di dominio ha un record di indirizzo (A o AAAA) che può essere risolto nell'indirizzo del mittente, corrisponderà. |
| IP4 | Se il mittente è in un dato range di indirizzi IPv4, corrisponde. |
| IP6 | Se il mittente è in un dato range di indirizzi IPv6, corrisponde. |
| MX | Se il nome di dominio ha un record MX che risolve nell'indirizzo del mittente, corrisponderà (cioè la posta proviene da uno dei server di posta in arrivo del dominio). |
| PTR | Se il nome di dominio (record PTR) per l'indirizzo del cliente è nel dominio dato e quel nome di dominio si risolve nell'indirizzo del cliente (DNS inverso confermato), corrisponde. Questo meccanismo è sconsigliato e dovrebbe essere evitato, se possibile. |
| EXISTS | Se il nome di dominio dato si risolve in qualsiasi indirizzo, corrisponde (indipendentemente dall'indirizzo a cui si risolve). Questo è raramente usato. Insieme al linguaggio macro SPF offre corrispondenze più complesse come le query DNSBL. |
| INCLUDE | Riferisce alla politica di un altro dominio. Se la politica di quel dominio passa, questo meccanismo passa. Tuttavia, se la politica inclusa fallisce, l'elaborazione continua. Per delegare completamente alla politica di un altro dominio, deve essere utilizzata l'estensione di reindirizzamento. |
| REDIRECT | <p>Un reindirizzamento è un puntatore a un altro nome di dominio che ospita una politica SPF, consente a più domini di condividere la stessa politica SPF. È utile quando si lavora con un gran numero di domini che condividono la stessa infrastruttura email.</p><p>La politica SPF del dominio indicato nel meccanismo di reindirizzamento sarà utilizzata.</p> |
| ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ALL | Corrisponde sempre; utilizzato per un risultato predefinito come `-all` per tutti gli IP non corrispondenti ai meccanismi precedenti. |
| A | Se il nome di dominio ha un record di indirizzo (A o AAAA) che può essere risolto nell'indirizzo del mittente, corrisponderà. |
| IP4 | Se il mittente è in un dato range di indirizzi IPv4, corrisponde. |
| IP6 | Se il mittente è in un dato range di indirizzi IPv6, corrisponde. |
| MX | Se il nome di dominio ha un record MX che risolve nell'indirizzo del mittente, corrisponderà (cioè la posta proviene da uno dei server di posta in arrivo del dominio). |
| PTR | Se il nome di dominio (record PTR) per l'indirizzo del client è nel dominio dato e quel nome di dominio si risolve nell'indirizzo del client (DNS inverso confermato), corrisponde. Questo meccanismo è sconsigliato e dovrebbe essere evitato, se possibile. |
| EXISTS | Se il nome di dominio dato si risolve in qualsiasi indirizzo, corrisponde (indipendentemente dall'indirizzo a cui si risolve). Questo è raramente usato. Insieme al linguaggio macro SPF offre corrispondenze più complesse come le query DNSBL. |
| INCLUDE | Riferisce alla politica di un altro dominio. Se la politica di quel dominio passa, questo meccanismo passa. Tuttavia, se la politica inclusa fallisce, l'elaborazione continua. Per delegare completamente alla politica di un altro dominio, deve essere utilizzata l'estensione di reindirizzamento. |
| REDIRECT | <p>Un reindirizzamento è un puntatore a un altro nome di dominio che ospita una politica SPF, consente a più domini di condividere la stessa politica SPF. È utile quando si lavora con un gran numero di domini che condividono la stessa infrastruttura email.</p><p>La politica SPF del dominio indicato nel meccanismo di reindirizzamento sarà utilizzata.</p> |
È anche possibile identificare **Qualificatori** che indicano **cosa dovrebbe essere fatto se un meccanismo corrisponde**. Per impostazione predefinita, viene utilizzato il **qualificatore "+"** (quindi se qualsiasi meccanismo corrisponde, significa che è consentito).\
È anche possibile identificare **Qualificatori** che indicano **cosa dovrebbe essere fatto se un meccanismo corrisponde**. Per impostazione predefinita, viene utilizzato il **qualificatore "+"** (quindi se un meccanismo corrisponde, significa che è consentito).\
Di solito noterai **alla fine di ogni politica SPF** qualcosa come: **\~all** o **-all**. Questo viene utilizzato per indicare che **se il mittente non corrisponde a nessuna politica SPF, dovresti contrassegnare l'email come non affidabile (\~) o rifiutare (-) l'email.**
#### Qualificatori
@ -324,14 +324,14 @@ _dmarc.bing.com. 3600 IN TXT "v=DMARC1; p=none; pct=100; rua=mailto:BingEmailDMA
| Tag Name | Purpose | Sample |
| -------- | --------------------------------------------- | ------------------------------- |
| v | Protocol version | v=DMARC1 |
| pct | Percentage of messages subjected to filtering | pct=20 |
| ruf | Reporting URI for forensic reports | ruf=mailto:authfail@example.com |
| rua | Reporting URI of aggregate reports | rua=mailto:aggrep@example.com |
| p | Policy for organizational domain | p=quarantine |
| sp | Policy for subdomains of the OD | sp=reject |
| adkim | Alignment mode for DKIM | adkim=s |
| aspf | Alignment mode for SPF | aspf=r |
| v | Versione del protocollo | v=DMARC1 |
| pct | Percentuale di messaggi soggetti a filtraggio| pct=20 |
| ruf | URI di reporting per rapporti forensi | ruf=mailto:authfail@example.com |
| rua | URI di reporting di rapporti aggregati | rua=mailto:aggrep@example.com |
| p | Politica per il dominio organizzativo | p=quarantine |
| sp | Politica per i sottodomini dell'OD | sp=reject |
| adkim | Modalità di allineamento per DKIM | adkim=s |
| aspf | Modalità di allineamento per SPF | aspf=r |
### **E i Sottodomini?**
@ -351,7 +351,7 @@ Questo ha senso: un sottodominio potrebbe trovarsi in una posizione geografica d
### **Open Relay**
Quando vengono inviate email, è fondamentale assicurarsi che non vengano contrassegnate come spam. Questo viene spesso realizzato attraverso l'uso di un **server di relay di cui si fida il destinatario**. Tuttavia, una sfida comune è che gli amministratori potrebbero non essere pienamente consapevoli di quali **intervalli IP siano sicuri da consentire**. Questa mancanza di comprensione può portare a errori nella configurazione del server SMTP, un rischio frequentemente identificato nelle valutazioni di sicurezza.
Quando vengono inviate email, è fondamentale garantire che non vengano contrassegnate come spam. Questo viene spesso realizzato attraverso l'uso di un **server di relay di cui si fida il destinatario**. Tuttavia, una sfida comune è che gli amministratori potrebbero non essere completamente consapevoli di quali **intervalli IP siano sicuri da consentire**. Questa mancanza di comprensione può portare a errori nella configurazione del server SMTP, un rischio frequentemente identificato nelle valutazioni di sicurezza.
Una soluzione alternativa che alcuni amministratori utilizzano per evitare problemi di consegna delle email, specialmente riguardo alle comunicazioni con clienti potenziali o in corso, è **consentire connessioni da qualsiasi indirizzo IP**. Questo viene fatto configurando il parametro `mynetworks` del server SMTP per accettare tutti gli indirizzi IP, come mostrato di seguito:
```bash
@ -366,7 +366,7 @@ nmap -p25 --script smtp-open-relay 10.10.10.10 -v
- [**https://github.com/serain/mailspoof**](https://github.com/serain/mailspoof) **Controlla le misconfigurazioni di SPF e DMARC**
- [**https://pypi.org/project/checkdmarc/**](https://pypi.org/project/checkdmarc/) **Ottieni automaticamente le configurazioni di SPF e DMARC**
### Invia Email Spoof
### Invia Email Fittizia
- [**https://www.mailsploit.com/index**](https://www.mailsploit.com/index)
- [**http://www.anonymailer.net/**](http://www.anonymailer.net)
@ -382,7 +382,7 @@ python3 magicspoofmail.py -d victim.com -t -e destination@gmail.com
python3 magicspoofmail.py -d victim.com -t -e destination@gmail.com --subject TEST --sender administrator@victim.com
```
> [!WARNING]
> Se ricevi un **errore utilizzando la libreria python dkim** durante l'analisi della chiave, sentiti libero di utilizzare la seguente.\
> Se ricevi un **errore utilizzando la libreria python dkim** durante l'analisi della chiave, sentiti libero di utilizzare questa seguente.\
> **NOTA**: Questa è solo una soluzione temporanea per effettuare controlli rapidi nei casi in cui, per qualche motivo, la chiave privata openssl **non può essere analizzata da dkim**.
>
> ```

24
src/network-services-pentesting/pentesting-snmp/README.md
View File

@ -2,7 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
## Informazioni di Base
**SNMP - Simple Network Management Protocol** è un protocollo utilizzato per monitorare diversi dispositivi nella rete (come router, switch, stampanti, IoT...).
@ -29,7 +28,7 @@ Inoltre, ai fornitori è concessa la libertà di stabilire rami privati. All'int
![](<../../images/SNMP_OID_MIB_Tree (1).png>)
Puoi **navigare** attraverso un **albero OID** dal web qui: [http://www.oid-info.com/cgi-bin/display?tree=#focus](http://www.oid-info.com/cgi-bin/display?tree=#focus) o **vedere cosa significa un OID** (come `1.3.6.1.2.1.1`) accedendo a [http://oid-info.com/get/1.3.6.1.2.1.1](http://oid-info.com/get/1.3.6.1.2.1.1).\
Ci sono alcuni **OID ben noti** come quelli all'interno di [1.3.6.1.2.1](http://oid-info.com/get/1.3.6.1.2.1) che fanno riferimento alle variabili del Simple Network Management Protocol (SNMP) definite in MIB-2. E dagli **OID in attesa di questo** puoi ottenere alcuni dati interessanti sull'host (dati di sistema, dati di rete, dati sui processi...)
Ci sono alcuni **OID ben noti** come quelli all'interno di [1.3.6.1.2.1](http://oid-info.com/get/1.3.6.1.2.1) che fanno riferimento alle variabili del Simple Network Management Protocol (SNMP) definite da MIB-2. E dagli **OID in attesa di questo** puoi ottenere alcuni dati interessanti sull'host (dati di sistema, dati di rete, dati sui processi...)
### **Esempio di OID**
@ -60,7 +59,7 @@ Il resto dei valori fornisce informazioni specifiche sul dispositivo.
- 1 – punto specifico nel dispositivo
- 3 – porta
- 21 – indirizzo della porta
- 1 – display per la porta
- 1 – visualizzazione per la porta
- 4 – numero del punto
- 7 – stato del punto
@ -68,7 +67,7 @@ Il resto dei valori fornisce informazioni specifiche sul dispositivo.
Ci sono 2 versioni importanti di SNMP:
- **SNMPv1**: La principale, è ancora la più frequente, l'**autenticazione si basa su una stringa** (community string) che viaggia in **testo semplice** (tutte le informazioni viaggiano in testo semplice). **Versione 2 e 2c** inviano il **traffico in testo semplice** anche e utilizzano una **community string come autenticazione**.
- **SNMPv1**: La principale, è ancora la più frequente, l'**autenticazione si basa su una stringa** (community string) che viaggia in **testo chiaro** (tutte le informazioni viaggiano in testo chiaro). **Versione 2 e 2c** inviano il **traffico in testo chiaro** anche e utilizzano una **community string come autenticazione**.
- **SNMPv3**: Utilizza una forma di **autenticazione** migliore e le informazioni viaggiano **crittografate** (un **attacco a dizionario** potrebbe essere eseguito ma sarebbe molto più difficile trovare le credenziali corrette rispetto a SNMPv1 e v2).
### Community Strings
@ -76,10 +75,10 @@ Ci sono 2 versioni importanti di SNMP:
Come accennato in precedenza, **per accedere alle informazioni salvate sulla MIB è necessario conoscere la community string nelle versioni 1 e 2/2c e le credenziali nella versione 3.**\
Ci sono **2 tipi di community strings**:
- **`public`** principalmente **funzioni di sola lettura**
- **`public`** principalmente funzioni **solo lettura**
- **`private`** **Lettura/Scrittura** in generale
Nota che **la scrivibilità di un OID dipende dalla community string utilizzata**, quindi **anche** se scopri che viene utilizzato "**public**", potresti essere in grado di **scrivere alcuni valori.** Inoltre, potrebbero **esistere** oggetti che sono **sempre "Read Only".**\
Nota che **la scrivibilità di un OID dipende dalla community string utilizzata**, quindi **anche** se scopri che viene utilizzato "**public**", potresti essere in grado di **scrivere alcuni valori.** Inoltre, potrebbero **esistere** oggetti che sono **sempre "Solo Lettura".**\
Se provi a **scrivere** un oggetto, si riceve un errore **`noSuchName` o `readOnly`**.\*\*.\*\*
Nelle versioni 1 e 2/2c, se utilizzi una community string **errata**, il server non **risponderà**. Quindi, se risponde, è stata utilizzata una **community string valida**.
@ -121,7 +120,7 @@ nmap --script "snmp* and not snmp-brute" <target>
braa <community string>@<IP>:.1.3.6.* #Bruteforce specific OID
```
Grazie alle query estese (download-mibs), è possibile enumerare ulteriormente il sistema con il seguente comando :
Grazie alle query estese (download-mibs), è possibile enumerare ancora di più sul sistema con il seguente comando :
```bash
snmpwalk -v X -c public <IP> NET-SNMP-EXTEND-MIB::nsExtendOutputFull
```
@ -150,7 +149,7 @@ Una serie di **valori della Management Information Base (MIB)** sono utilizzati
- **Processi di sistema**: Accessibile tramite `1.3.6.1.2.1.25.1.6.0`, questo parametro consente il monitoraggio dei processi attivi all'interno del sistema.
- **Programmi in esecuzione**: Il valore `1.3.6.1.2.1.25.4.2.1.2` è designato per tracciare i programmi attualmente in esecuzione.
- **Percorso dei processi**: Per determinare da dove sta girando un processo, viene utilizzato il valore MIB `1.3.6.1.2.1.25.4.2.1.4`.
- **Percorso dei processi**: Per determinare da dove proviene un processo, viene utilizzato il valore MIB `1.3.6.1.2.1.25.4.2.1.4`.
- **Unità di archiviazione**: Il monitoraggio delle unità di archiviazione è facilitato da `1.3.6.1.2.1.25.2.3.1.4`.
- **Nome del software**: Per identificare il software installato su un sistema, viene impiegato `1.3.6.1.2.1.25.6.3.1.2`.
- **Account utente**: Il valore `1.3.6.1.4.1.77.1.2.25` consente di tracciare gli account utente.
@ -174,7 +173,7 @@ snmp-rce.md
## **SNMP Massivo**
[Braa](https://github.com/mteg/braa) è uno scanner SNMP di massa. L'uso previsto di un tale strumento è, ovviamente, effettuare query SNMP – ma a differenza di snmpwalk di net-snmp, è in grado di interrogare dozzine o centinaia di host simultaneamente, e in un unico processo. Pertanto, consuma pochissime risorse di sistema e esegue la scansione MOLTO rapidamente.
[Braa](https://github.com/mteg/braa) è uno scanner SNMP di massa. L'uso previsto di un tale strumento è, ovviamente, effettuare query SNMP – ma a differenza di snmpwalk di net-snmp, è in grado di interrogare dozzine o centinaia di host simultaneamente, e in un unico processo. Pertanto, consuma pochissime risorse di sistema e esegue la scansione MOLTO velocemente.
Braa implementa il proprio stack SNMP, quindi non ha bisogno di librerie SNMP come net-snmp.
@ -188,7 +187,7 @@ Quindi, cerchiamo le informazioni più interessanti (da [https://blog.rapid7.com
### **Dispositivi**
Il processo inizia con l'estrazione dei dati **sysDesc MIB** (1.3.6.1.2.1.1.1.0) da ciascun file per identificare i dispositivi. Questo viene realizzato attraverso l'uso di un **grep command**:
Il processo inizia con l'estrazione dei dati **sysDesc MIB** (1.3.6.1.2.1.1.1.0) da ciascun file per identificare i dispositivi. Questo viene realizzato attraverso l'uso di un **comando grep**:
```bash
grep ".1.3.6.1.2.1.1.1.0" *.snmp
```
@ -210,7 +209,7 @@ Infine, per estrarre **indirizzi email** dai dati, viene utilizzato un **comando
```bash
grep -E -o "\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}\b" *.snmp
```
## Modifica dei valori SNMP
## Modificare i valori SNMP
Puoi usare _**NetScanTools**_ per **modificare i valori**. Dovrai conoscere la **stringa privata** per farlo.
@ -218,13 +217,12 @@ Puoi usare _**NetScanTools**_ per **modificare i valori**. Dovrai conoscere la *
Se c'è un ACL che consente solo ad alcuni IP di interrogare il servizio SMNP, puoi spoofare uno di questi indirizzi all'interno del pacchetto UDP e sniffare il traffico.
## Esamina i file di configurazione SNMP
## Esaminare i file di configurazione SNMP
- snmp.conf
- snmpd.conf
- snmp-config.xml
## Comandi automatici HackTricks
```
Protocol_Name: SNMP #Protocol Abbreviation if there is one.

4
src/network-services-pentesting/pentesting-telnet.md
View File

@ -13,7 +13,7 @@ Telnet è un protocollo di rete che offre agli utenti un modo NON sicuro per acc
```
## **Enumerazione**
### **Acquisizione del Banner**
### **Acquisizione Banner**
```bash
nc -vn <IP> 23
```
@ -23,7 +23,7 @@ nmap -n -sV -Pn --script "*telnet* and safe" -p 23 <IP>
```
Lo script `telnet-ntlm-info.nse` otterrà informazioni NTLM (versioni di Windows).
Dalla [telnet RFC](https://datatracker.ietf.org/doc/html/rfc854): Nel Protocollo TELNET ci sono varie "**opzioni**" che saranno sanzionate e possono essere utilizzate con la struttura "**DO, DON'T, WILL, WON'T**" per consentire a un utente e a un server di concordare l'uso di un insieme più elaborato (o forse semplicemente diverso) di convenzioni per la loro connessione TELNET. Tali opzioni potrebbero includere la modifica del set di caratteri, la modalità di eco, ecc.
Dalla [telnet RFC](https://datatracker.ietf.org/doc/html/rfc854): Nel protocollo TELNET ci sono varie "**opzioni**" che saranno sanzionate e possono essere utilizzate con la struttura "**DO, DON'T, WILL, WON'T**" per consentire a un utente e a un server di concordare l'uso di un insieme più elaborato (o forse semplicemente diverso) di convenzioni per la loro connessione TELNET. Tali opzioni potrebbero includere la modifica del set di caratteri, la modalità di eco, ecc.
**So che è possibile enumerare queste opzioni, ma non so come, quindi fammi sapere se sai come.**

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

@ -96,9 +96,9 @@ Alcuni **trucchi** per **trovare vulnerabilità** in diverse **tecnologie** ben
- [**WebDav**](put-method-webdav.md)
- [**Werkzeug**](werkzeug.md)
- [**Wordpress**](wordpress.md)
- [**Electron Desktop (XSS a RCE)**](electron-desktop-apps/index.html)
- [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html)
_Tieni presente che il **stesso dominio** può utilizzare **tecnologie diverse** in **porte**, **cartelle** e **sottodomini** diversi._\
_Tieni presente che il **stesso dominio** può utilizzare **tecnologie diverse** su **porte**, **cartelle** e **sottodomini** diversi._\
Se l'applicazione web utilizza qualche **tecnologia/piattaforma ben nota elencata sopra** o **qualsiasi altra**, non dimenticare di **cercare su Internet** nuovi trucchi (e fammi sapere!).
### Revisione del codice sorgente
@ -145,7 +145,7 @@ wpscan --force update -e --url <URL>
joomscan --ec -u <URL>
joomlavs.rb #https://github.com/rastating/joomlavs
```
> A questo punto dovresti già avere alcune informazioni sul server web utilizzato dal cliente (se sono stati forniti dati) e alcuni trucchi da tenere a mente durante il test. Se sei fortunato, hai persino trovato un CMS e eseguito qualche scanner.
> A questo punto dovresti già avere alcune informazioni sul server web utilizzato dal cliente (se sono disponibili dati) e alcuni trucchi da tenere a mente durante il test. Se sei fortunato, hai persino trovato un CMS e eseguito qualche scanner.
## Scoperta dell'applicazione web passo dopo passo
@ -164,9 +164,9 @@ joomlavs.rb #https://github.com/rastating/joomlavs
**Forzare errori**
I server web possono **comportarsi in modo imprevisto** quando dati strani vengono inviati loro. Questo può aprire **vulnerabilità** o **divulgare informazioni sensibili**.
I server web possono **comportarsi in modo imprevisto** quando dati strani vengono inviati. Questo può aprire **vulnerabilità** o **divulgare informazioni sensibili**.
- Accedi a **pagine false** come /whatever_fake.php (.aspx,.html,.etc)
- Accedi a **pagine false** come /whatever_fake.php (.aspx,.html,.ecc)
- **Aggiungi "\[]", "]]" e "\[\["** nei **valori dei cookie** e nei **valori dei parametri** per creare errori
- Genera errori fornendo input come **`/~randomthing/%s`** alla **fine** dell'**URL**
- Prova **diversi verbi HTTP** come PATCH, DEBUG o errati come FAKE
@ -181,7 +181,7 @@ Se scopri che **WebDav** è **abilitato** ma non hai abbastanza permessi per **c
### **Vulnerabilità SSL/TLS**
- Se l'applicazione **non costringe l'uso di HTTPS** in nessuna parte, allora è **vulnerabile a MitM**
- Se l'applicazione sta **inviando dati sensibili (password)** utilizzando HTTP. Allora è una vulnerabilità alta.
- Se l'applicazione **invia dati sensibili (password)** utilizzando HTTP. Allora è una vulnerabilità alta.
Usa [**testssl.sh**](https://github.com/drwetter/testssl.sh) per controllare le **vulnerabilità** (nei programmi di Bug Bounty probabilmente questo tipo di vulnerabilità non sarà accettato) e usa [**a2sv**](https://github.com/hahwul/a2sv) per ricontrollare le vulnerabilità:
```bash
@ -211,7 +211,7 @@ Lanciare qualche tipo di **spider** all'interno del web. L'obiettivo dello spide
- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Questo script troverà URL con parametri e li elencherà.
- [**galer**](https://github.com/dwisiswant0/galer) (go): spider HTML con capacità di rendering JS.
- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): spider HTML, con capacità di abbellimento JS in grado di cercare nuovi percorsi in file JS. Potrebbe valere la pena dare un'occhiata anche a [JSScanner](https://github.com/dark-warlord14/JSScanner), che è un wrapper di LinkFinder.
- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Per estrarre endpoint sia nel sorgente HTML che nei file javascript incorporati. Utile per cacciatori di bug, red teamers, ninja della sicurezza informatica.
- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Per estrarre endpoint sia nel sorgente HTML che nei file javascript incorporati. Utile per cacciatori di bug, red teamers, ninja dell'infosec.
- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Uno script python 2.7 che utilizza Tornado e JSBeautifier per analizzare URL relativi da file JavaScript. Utile per scoprire facilmente richieste AJAX. Sembra non essere mantenuto.
- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dato un file (HTML) estrarrà URL da esso utilizzando espressioni regolari per trovare ed estrarre gli URL relativi da file brutti (minificati).
- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, diversi strumenti): Raccogliere informazioni interessanti da file JS utilizzando diversi strumenti.
@ -219,7 +219,7 @@ Lanciare qualche tipo di **spider** all'interno del web. L'obiettivo dello spide
- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Carica una pagina in un browser headless e stampa tutti gli URL caricati per caricare la pagina.
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Strumento di scoperta dei contenuti che mescola diverse opzioni degli strumenti precedenti.
- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Un'estensione di Burp per trovare percorsi e parametri in file JS.
- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Uno strumento che, dato l'URL .js.map, ti fornirà il codice JS abbellito.
- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Uno strumento che dato l'URL .js.map ti fornirà il codice JS abbellito.
- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Questo è uno strumento utilizzato per scoprire endpoint per un dato target.
- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Scoprire link dalla wayback machine (scaricando anche le risposte nella wayback e cercando ulteriori link).
- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (anche compilando moduli) e trova anche informazioni sensibili utilizzando regex specifici.
@ -240,9 +240,9 @@ Strumenti:
- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Veloce, supporta ricerca ricorsiva.**
- [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
- [**ffuf** ](https://github.com/ffuf/ffuf)- Veloce: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
- [**uro**](https://github.com/s0md3v/uro) (python): Questo non è uno spider ma uno strumento che, data la lista di URL trovati, eliminerà gli URL "duplicati".
- [**uro**](https://github.com/s0md3v/uro) (python): Questo non è uno spider ma uno strumento che dato l'elenco di URL trovati eliminerà gli URL "duplicati".
- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Estensione di Burp per creare un elenco di directory dalla cronologia di burp di diverse pagine.
- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Rimuovi URL con funzionalità duplicate (basato su importazioni js).
- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Rimuove URL con funzionalità duplicate (basato su importazioni js).
- [**Chamaleon**](https://github.com/iustin24/chameleon): Utilizza wapalyzer per rilevare le tecnologie utilizzate e selezionare le wordlist da utilizzare.
**Dizionari consigliati:**
@ -266,39 +266,39 @@ Strumenti:
_Nota che ogni volta che viene scoperta una nuova directory durante il brute-forcing o lo spidering, dovrebbe essere Brute-Forzata._
### Cosa controllare in ogni file trovato
### Cosa controllare su ogni file trovato
- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Trova link rotti all'interno degli HTML che potrebbero essere soggetti a takeover.
- **File di backup**: Una volta trovati tutti i file, cerca i backup di tutti i file eseguibili ("_.php_", "_.aspx_"...). Le variazioni comuni per nominare un backup sono: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp e file.old._ Puoi anche utilizzare lo strumento [**bfac**](https://github.com/mazen160/bfac) **o** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
- **Scoprire nuovi parametri**: Puoi utilizzare strumenti come [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **e** [**Param Miner**](https://github.com/PortSwigger/param-miner) **per scoprire parametri nascosti. Se puoi, potresti provare a cercare** parametri nascosti in ogni file web eseguibile.
- **Scoprire nuovi parametri**: Puoi utilizzare strumenti come [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **e** [**Param Miner**](https://github.com/PortSwigger/param-miner) **per scoprire parametri nascosti. Se puoi, potresti provare a cercare** parametri nascosti in ciascun file web eseguibile.
- _Arjun tutte le wordlist predefinite:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
- _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params)
- _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
- _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
- **Commenti:** Controlla i commenti di tutti i file, puoi trovare **credenziali** o **funzionalità nascoste**.
- Se stai partecipando a un **CTF**, un trucco "comune" è **nascondere** **informazioni** all'interno dei commenti a destra della **pagina** (utilizzando **centinaia** di **spazi** in modo da non vedere i dati se apri il codice sorgente con il browser). Un'altra possibilità è utilizzare **diverse nuove righe** e **nascondere informazioni** in un commento in fondo alla pagina web.
- **Chiavi API**: Se **trovi una chiave API** c'è una guida che indica come utilizzare le chiavi API di diverse piattaforme: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird).
- Chiavi API di Google: Se trovi una chiave API che assomiglia a **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puoi utilizzare il progetto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) per controllare quali API la chiave può accedere.
- **S3 Buckets**: Durante lo spidering controlla se qualche **sottodominio** o qualche **link** è correlato a qualche **S3 bucket**. In tal caso, [**controlla** le **permissive** del bucket](buckets/index.html).
- **API keys**: Se **trovi qualche API key** c'è una guida che indica come utilizzare le API key di diverse piattaforme: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird).
- Google API keys: Se trovi qualche API key che assomiglia a **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puoi utilizzare il progetto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) per controllare quali API la chiave può accedere.
- **S3 Buckets**: Durante lo spidering controlla se qualche **subdominio** o qualche **link** è correlato a qualche **S3 bucket**. In tal caso, [**controlla** le **permissive** del bucket](buckets/index.html).
### Scoperte speciali
**Mentre** esegui lo **spidering** e il **brute-forcing** potresti trovare **cose** **interessanti** che devi **notare**.
**Mentre** esegui lo **spidering** e il **brute-forcing** potresti trovare **cose** **interessanti** di cui devi **prendere nota**.
**File interessanti**
- Cerca **link** ad altri file all'interno dei file **CSS**.
- [Se trovi un file _**.git**_ alcune informazioni possono essere estratte](git.md).
- Se trovi un _**.env**_ informazioni come chiavi API, password db e altre informazioni possono essere trovate.
- Se trovi **endpoint API** dovresti [testarli anche](web-api-pentesting.md). Questi non sono file, ma probabilmente "sembreranno" tali.
- **File JS**: Nella sezione spidering sono stati menzionati diversi strumenti che possono estrarre percorsi da file JS. Inoltre, sarebbe interessante **monitorare ogni file JS trovato**, poiché in alcune occasioni, una modifica può indicare che una potenziale vulnerabilità è stata introdotta nel codice. Potresti usare ad esempio [**JSMon**](https://github.com/robre/jsmon)**.**
- Se trovi **API endpoints** dovresti [testarli anche](web-api-pentesting.md). Questi non sono file, ma probabilmente "sembreranno" tali.
- **File JS**: Nella sezione spidering sono stati menzionati diversi strumenti che possono estrarre percorsi da file JS. Inoltre, sarebbe interessante **monitorare ogni file JS trovato**, poiché in alcune occasioni, una modifica potrebbe indicare che una potenziale vulnerabilità è stata introdotta nel codice. Potresti usare ad esempio [**JSMon**](https://github.com/robre/jsmon)**.**
- Dovresti anche controllare i file JS scoperti con [**RetireJS**](https://github.com/retirejs/retire.js/) o [**JSHole**](https://github.com/callforpapers-source/jshole) per scoprire se è vulnerabile.
- **Deobfuscator e Unpacker Javascript:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator).
- **Beautifier Javascript:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org).
- **Deobfuscazione JsFuck** (javascript con caratteri:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)).
- **Javascript Deobfuscator e Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator).
- **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org).
- **JsFuck deobfuscation** (javascript con caratteri:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)).
- [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
- In diverse occasioni, sarà necessario **comprendere le espressioni regolari** utilizzate. Questo sarà utile: [https://regex101.com/](https://regex101.com) o [https://pythonium.net/regex](https://pythonium.net/regex).
- Potresti anche **monitorare i file in cui sono stati rilevati moduli**, poiché una modifica nel parametro o l'apparizione di un nuovo modulo può indicare una potenziale nuova funzionalità vulnerabile.
- Potresti anche **monitorare i file in cui sono stati rilevati moduli**, poiché una modifica nel parametro o l'apparizione di un nuovo modulo potrebbe indicare una potenziale nuova funzionalità vulnerabile.
**403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**
@ -308,9 +308,9 @@ _Nota che ogni volta che viene scoperta una nuova directory durante il brute-for
**502 Proxy Error**
Se una pagina **risponde** con quel **codice**, è probabilmente un **proxy mal configurato**. **Se invii una richiesta HTTP come: `GET https://google.com HTTP/1.1`** (con l'intestazione host e altre intestazioni comuni), il **proxy** cercherà di **accedere** a _**google.com**_ **e avrai trovato un** SSRF.
Se qualche pagina **risponde** con quel **codice**, è probabilmente un **proxy mal configurato**. **Se invii una richiesta HTTP come: `GET https://google.com HTTP/1.1`** (con l'intestazione host e altre intestazioni comuni), il **proxy** cercherà di **accedere** a _**google.com**_ **e avrai trovato un** SSRF.
**Autenticazione NTLM - Informazioni riservate**
**NTLM Authentication - Info disclosure**
Se il server in esecuzione richiede autenticazione è **Windows** o trovi un login che richiede le tue **credenziali** (e richiede il **nome del dominio**), puoi provocare una **divulgazione di informazioni**.\
**Invia** l'**intestazione**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` e a causa di come funziona l'**autenticazione NTLM**, il server risponderà con informazioni interne (versione IIS, versione Windows...) all'interno dell'intestazione "WWW-Authenticate".\
@ -318,11 +318,11 @@ Puoi **automatizzare** questo utilizzando il **plugin nmap** "_http-ntlm-info.ns
**HTTP Redirect (CTF)**
È possibile **inserire contenuti** all'interno di una **Redirection**. Questo contenuto **non sarà mostrato all'utente** (poiché il browser eseguirà il reindirizzamento) ma qualcosa potrebbe essere **nascosto** lì.
È possibile **inserire contenuti** all'interno di una **Redirection**. Questo contenuto **non sarà mostrato all'utente** (poiché il browser eseguirà la redirezione) ma qualcosa potrebbe essere **nascosto** lì dentro.
### Controllo delle vulnerabilità web
Ora che è stata eseguita un'ampia enumerazione dell'applicazione web, è tempo di controllare molte possibili vulnerabilità. Puoi trovare la checklist qui:
Ora che è stata eseguita un'enumerazione completa dell'applicazione web, è tempo di controllare molte possibili vulnerabilità. Puoi trovare la checklist qui:
{{#ref}}
../../pentesting-web/web-vulnerabilities-methodology.md

20
src/network-services-pentesting/pentesting-web/angular.md
View File

@ -14,7 +14,7 @@ Checklist [da qui](https://lsgeurope.com/post/angular-security-checklist).
## What is Angular
Angular è un **framework** front-end **potente** e **open-source** mantenuto da **Google**. Utilizza **TypeScript** per migliorare la leggibilità del codice e il debug. Con forti meccanismi di sicurezza, Angular previene vulnerabilità comuni lato client come **XSS** e **open redirects**. Può essere utilizzato anche lato **server**, rendendo importanti le considerazioni sulla sicurezza da **entrambi i lati**.
Angular è un **framework** front-end **potente** e **open-source** mantenuto da **Google**. Utilizza **TypeScript** per migliorare la leggibilità del codice e il debug. Con forti meccanismi di sicurezza, Angular previene vulnerabilità comuni lato client come **XSS** e **redirect aperti**. Può essere utilizzato anche lato **server**, rendendo importanti le considerazioni sulla sicurezza da **entrambi i lati**.
## Framework architecture
@ -39,7 +39,7 @@ my-workspace/
├── angular.json #provides workspace-wide and project-specific configuration defaults
└── tsconfig.json #provides the base TypeScript configuration for projects in the workspace
```
Secondo la documentazione, ogni applicazione Angular ha almeno un componente, il componente radice (`AppComponent`) che collega una gerarchia di componenti con il DOM. Ogni componente definisce una classe che contiene dati e logica dell'applicazione ed è associato a un modello HTML che definisce una vista da visualizzare in un ambiente target. Il decoratore `@Component()` identifica la classe immediatamente sottostante come un componente e fornisce il modello e i metadati specifici del componente correlati. L'`AppComponent` è definito nel file `app.component.ts`.
Secondo la documentazione, ogni applicazione Angular ha almeno un componente, il componente radice (`AppComponent`) che collega una gerarchia di componenti con il DOM. Ogni componente definisce una classe che contiene dati e logica dell'applicazione ed è associata a un modello HTML che definisce una vista da visualizzare in un ambiente target. Il decoratore `@Component()` identifica la classe immediatamente sottostante come un componente e fornisce il modello e i metadati specifici del componente correlati. L'`AppComponent` è definito nel file `app.component.ts`.
Gli Angular NgModules dichiarano un contesto di compilazione per un insieme di componenti dedicato a un dominio dell'applicazione, a un flusso di lavoro o a un insieme di capacità strettamente correlate. Ogni applicazione Angular ha un modulo radice, convenzionalmente chiamato `AppModule`, che fornisce il meccanismo di avvio che lancia l'applicazione. Un'applicazione contiene tipicamente molti moduli funzionali. L'`AppModule` è definito nel file `app.module.ts`.
@ -49,7 +49,7 @@ Per dati o logica che non sono associati a una vista specifica e che desideri co
## Configurazione del sourcemap
Il framework Angular traduce i file TypeScript in codice JavaScript seguendo le opzioni di `tsconfig.json` e poi costruisce un progetto con la configurazione di `angular.json`. Guardando il file `angular.json`, abbiamo osservato un'opzione per abilitare o disabilitare un sourcemap. Secondo la documentazione di Angular, la configurazione predefinita ha un file sourcemap abilitato per gli script e non è nascosto per impostazione predefinita:
Il framework Angular traduce i file TypeScript in codice JavaScript seguendo le opzioni di `tsconfig.json` e poi costruisce un progetto con la configurazione di `angular.json`. Esaminando il file `angular.json`, abbiamo osservato un'opzione per abilitare o disabilitare un sourcemap. Secondo la documentazione di Angular, la configurazione predefinita ha un file sourcemap abilitato per gli script e non è nascosto per impostazione predefinita:
```json
"sourceMap": {
"scripts": true,
@ -114,14 +114,14 @@ Ci sono 6 tipi di `SecurityContext` :
* `None`;
* `HTML` viene utilizzato quando si interpreta il valore come HTML;
* `STYLE` viene utilizzato quando si collega il CSS alla proprietà `style`;
* `STYLE` viene utilizzato quando si lega il CSS nella proprietà `style`;
* `URL` viene utilizzato per le proprietà URL, come `<a href>`;
* `SCRIPT` viene utilizzato per il codice JavaScript;
* `RESOURCE_URL` come un URL che viene caricato ed eseguito come codice, ad esempio, in `<script src>`.
## Vulnerabilità
### Bypass Security Trust methods
### Bypass dei metodi di sicurezza Trust
Angular introduce un elenco di metodi per bypassare il suo processo di sanitizzazione predefinito e per indicare che un valore può essere utilizzato in modo sicuro in un contesto specifico, come nei seguenti cinque esempi:
@ -162,7 +162,7 @@ this.trustedHtml = this.sanitizer.bypassSecurityTrustHtml("<h1>html tag</h1><svg
<h1>html tag</h1>
<svg onclick="alert('bypassSecurityTrustHtml')" style="display:block">blah</svg>
```
4. `bypassSecurityTrustScript` viene utilizzato per indicare che il valore fornito è JavaScript sicuro. Tuttavia, abbiamo riscontrato che il suo comportamento è imprevedibile, poiché non siamo riusciti a eseguire codice JS nei template utilizzando questo metodo.
4. `bypassSecurityTrustScript` viene utilizzato per indicare che il valore fornito è JavaScript sicuro. Tuttavia, abbiamo riscontrato che il suo comportamento è imprevedibile, perché non siamo riusciti a eseguire codice JS nei template utilizzando questo metodo.
```jsx
//app.component.ts
@ -227,7 +227,7 @@ selector: 'app-root',
template: '<h1>title</h1>' + _userInput
})
```
Come mostrato sopra: `constructor` si riferisce all'ambito della proprietà Object `constructor`, permettendoci di invocare il costruttore String e eseguire un codice arbitrario.
Come mostrato sopra: `constructor` si riferisce all'ambito della proprietà Object `constructor`, consentendoci di invocare il costruttore String ed eseguire un codice arbitrario.
#### Rendering lato server (SSR)
@ -375,7 +375,7 @@ Durante la nostra ricerca, abbiamo anche esaminato il comportamento di altri met
#### jQuery
jQuery è una libreria JavaScript veloce, piccola e ricca di funzionalità che può essere utilizzata nel progetto Angular per aiutare con la manipolazione degli oggetti DOM HTML. Tuttavia, come è noto, i metodi di questa libreria possono essere sfruttati per ottenere una vulnerabilità XSS. Per discutere di come alcuni metodi vulnerabili di jQuery possano essere sfruttati nei progetti Angular, abbiamo aggiunto questa sottosezione.
jQuery è una libreria JavaScript veloce, leggera e ricca di funzionalità che può essere utilizzata nel progetto Angular per aiutare con la manipolazione degli oggetti DOM HTML. Tuttavia, come è noto, i metodi di questa libreria possono essere sfruttati per ottenere una vulnerabilità XSS. Per discutere di come alcuni metodi vulnerabili di jQuery possano essere sfruttati nei progetti Angular, abbiamo aggiunto questa sottosezione.
* Il metodo `html()` ottiene i contenuti HTML del primo elemento nel set di elementi corrispondenti o imposta i contenuti HTML di ogni elemento corrispondente. Tuttavia, per design, qualsiasi costruttore o metodo jQuery che accetta una stringa HTML può potenzialmente eseguire codice. Questo può avvenire tramite l'iniezione di tag `<script>` o l'uso di attributi HTML che eseguono codice, come mostrato nell'esempio.
@ -410,7 +410,7 @@ $("p").html("<script>alert(1)</script>");
jQuery.parseHTML(data [, context ] [, keepScripts ])
```
Come accennato in precedenza, la maggior parte delle API jQuery che accettano stringhe HTML eseguiranno script inclusi nell'HTML. Il metodo `jQuery.parseHTML()` non esegue script nell'HTML analizzato a meno che `keepScripts` non sia esplicitamente `true`. Tuttavia, è ancora possibile in molti ambienti eseguire script indirettamente; ad esempio, tramite l'attributo `<img onerror>`.
Come accennato in precedenza, la maggior parte delle API jQuery che accettano stringhe HTML eseguiranno script inclusi nell'HTML. Il metodo `jQuery.parseHTML()` non esegue script nell'HTML analizzato a meno che `keepScripts` non sia esplicitamente `true`. Tuttavia, è ancora possibile nella maggior parte degli ambienti eseguire script indirettamente; ad esempio, tramite l'attributo `<img onerror>`.
```tsx
//app.component.ts
@ -496,7 +496,7 @@ window.location.replace("http://google.com/about")
```
* `window.open()`
Il metodo `window.open()` prende un URL e carica la risorsa che identifica in una nuova scheda o finestra esistente. Avere il controllo su questo metodo potrebbe anche essere un'opportunità per innescare una vulnerabilità XSS o di open redirect.
Il metodo `window.open()` prende un URL e carica la risorsa che identifica in una nuova scheda o finestra esistente. Avere il controllo su questo metodo potrebbe anche essere un'opportunità per innescare una vulnerabilità XSS o open redirect.
```tsx
//app.component.ts

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

@ -4,7 +4,7 @@
## Cos'è Firebase
Firebase è un Backend-as-a-Service principalmente per applicazioni mobili. È focalizzato sulla rimozione del carico di programmazione del back-end fornendo un bel SDK così come molte altre cose interessanti che facilitano l'interazione tra l'applicazione e il back-end.
Firebase è un Backend-as-a-Services principalmente per applicazioni mobili. È focalizzato sull'eliminazione del carico di programmazione del back-end fornendo un bel SDK così come molte altre cose interessanti che facilitano l'interazione tra l'applicazione e il back-end.
Scopri di più su Firebase in:

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

@ -81,10 +81,10 @@ AAA<--SNIP 232 A-->AAA.php.png
- **Possibile divulgazione di informazioni**:
1. Carica **più volte** (e **allo stesso tempo**) lo **stesso file** con lo **stesso nome**
2. Carica un file con il **nome** di un **file** o **cartella** che **esiste già**
3. Caricando un file con **“.”, “..”, o “…” come nome**. Ad esempio, in Apache in **Windows**, se l'applicazione salva i file caricati nella directory “/www/uploads/”, il nome file “.” creerà un file chiamato “uploads” nella directory “/www/”.
3. Caricando un file con **“.”, “..”, o “…” come nome**. Ad esempio, in Apache in **Windows**, se l'applicazione salva i file caricati nella directory “/www/uploads/”, il nome del file “.” creerà un file chiamato “uploads” nella directory “/www/”.
4. Carica un file che potrebbe non essere facilmente eliminato come **“…:.jpg”** in **NTFS**. (Windows)
5. Carica un file in **Windows** con **caratteri non validi** come `|<>*?”` nel suo nome. (Windows)
6. Carica un file in **Windows** usando **nomi riservati** (**vietati**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
6. Carica un file in **Windows** utilizzando **nomi riservati** (**vietati**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
- Prova anche a **caricare un eseguibile** (.exe) o un **.html** (meno sospetto) che **eseguirà codice** quando accidentalmente aperto dalla vittima.
### Special extension tricks
@ -94,7 +94,7 @@ Se stai cercando di caricare file su un **server ASP**, [dai un'occhiata al truc
I file `.phar` sono come i `.jar` per java, ma per php, e possono essere **usati come un file php** (eseguendolo con php, o includendolo all'interno di uno script...)
L'estensione `.inc` è a volte usata per file php che vengono utilizzati solo per **importare file**, quindi, a un certo punto, qualcuno potrebbe aver consentito **l'esecuzione di questa estensione**.
L'estensione `.inc` è a volte usata per file php che sono solo usati per **importare file**, quindi, a un certo punto, qualcuno potrebbe aver permesso **che questa estensione fosse eseguita**.
## **Jetty RCE**
@ -106,7 +106,7 @@ Se puoi caricare un file XML su un server Jetty puoi ottenere [RCE perché **nuo
Per un'esplorazione dettagliata di questa vulnerabilità controlla la ricerca originale: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la capacità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI sfruttano una sintassi specifica per incorporare variabili "magiche", segnaposto e operatori. In particolare, l'operatore '@', utilizzato come `@(filename)`, è progettato per includere i contenuti di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, consentendo la lettura dei dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi nefasti come Remote Command Execution o Arbitrary File Write/Read quando un file di configurazione `.ini` viene elaborato.
Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la capacità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI sfruttano una sintassi specifica per incorporare variabili "magiche", segnaposto e operatori. Notabilmente, l'operatore '@', utilizzato come `@(filename)`, è progettato per includere i contenuti di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, consentendo la lettura dei dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi nefasti come Remote Command Execution o Arbitrary File Write/Read quando un file di configurazione `.ini` viene elaborato.
Considera il seguente esempio di un file `uwsgi.ini` dannoso, che mostra vari schemi:
```ini
@ -220,7 +220,7 @@ tar -cvf test.tar symindex.txt
```
### Decompress in different folders
La creazione imprevista di file in directory durante la decompressione è un problema significativo. Nonostante le assunzioni iniziali che questa configurazione potesse proteggere contro l'esecuzione di comandi a livello di OS tramite caricamenti di file dannosi, il supporto per la compressione gerarchica e le capacità di traversamento delle directory del formato ZIP possono essere sfruttati. Questo consente agli attaccanti di eludere le restrizioni e di uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione mirata.
La creazione imprevista di file in directory durante la decompressione è un problema significativo. Nonostante le assunzioni iniziali che questa configurazione potesse proteggere contro l'esecuzione di comandi a livello di OS tramite caricamenti di file dannosi, il supporto per la compressione gerarchica e le capacità di traversata delle directory del formato ZIP possono essere sfruttati. Questo consente agli attaccanti di eludere le restrizioni e di uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione mirata.
Un exploit automatizzato per creare tali file è disponibile su [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). L'utilità può essere utilizzata come mostrato:
```python
@ -297,7 +297,7 @@ Maggiore informazione in: [https://www.idontplaydarts.com/2012/06/encoding-web-s
## Polyglot Files
I file poliglotti servono come uno strumento unico nella cybersecurity, agendo come camaleonti che possono esistere validamente in più formati di file contemporaneamente. Un esempio intrigante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF che come archivio RAR. Tali file non sono limitati a questa combinazione; sono anche fattibili combinazioni come GIF e JS o PPT e JS.
I file poliglotti servono come uno strumento unico nella cybersecurity, agendo come camaleonti che possono esistere validamente in più formati di file contemporaneamente. Un esempio intrigante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF che come archivio RAR. Tali file non sono limitati a questa combinazione; sono possibili anche combinazioni come GIF e JS o PPT e JS.
L'utilità principale dei file poliglotti risiede nella loro capacità di eludere le misure di sicurezza che filtrano i file in base al tipo. La prassi comune in varie applicazioni prevede di consentire solo determinati tipi di file per il caricamento—come JPEG, GIF o DOC—per mitigare il rischio posto da formati potenzialmente dannosi (ad es., JS, PHP o file Phar). Tuttavia, un poliglott, conformandosi ai criteri strutturali di più tipi di file, può eludere furtivamente queste restrizioni.

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

@ -44,13 +44,13 @@ https://socialmedia.com/auth
```
https://example.com?code=uniqueCode123&state=randomString123
```
5. https://example.com utilizza questo `code`, insieme al suo `client_id` e `client_secret`, per effettuare una richiesta lato server per ottenere un `access_token` per tuo conto, consentendo l'accesso alle autorizzazioni a cui hai acconsentito:
5. https://example.com utilizza questo `code`, insieme al suo `client_id` e `client_secret`, per effettuare una richiesta lato server per ottenere un `access_token` per tuo conto, abilitando l'accesso alle autorizzazioni a cui hai acconsentito:
```
POST /oauth/access_token
Host: socialmedia.com
...{"client_id": "example_clientId", "client_secret": "example_clientSecret", "code": "uniqueCode123", "grant_type": "authorization_code"}
```
6. Infine, il processo si conclude quando https://example.com utilizza il tuo `access_token` per effettuare una chiamata API a Social Media per accedere
6. Infine, il processo si conclude quando https://example.com utilizza il tuo `access_token` per effettuare una chiamata API ai Social Media per accedere
## Vulnerabilità <a href="#id-323a" id="id-323a"></a>
@ -74,7 +74,7 @@ https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard</scrip
Nelle implementazioni di OAuth, l'uso improprio o l'omissione del **`state` parameter** può aumentare significativamente il rischio di attacchi di **Cross-Site Request Forgery (CSRF)**. Questa vulnerabilità si verifica quando il parametro `state` è **non utilizzato, utilizzato come valore statico o non validato correttamente**, consentendo agli attaccanti di eludere le protezioni CSRF.
Gli attaccanti possono sfruttare questo intercettando il processo di autorizzazione per collegare il proprio account a quello della vittima, portando a potenziali **account takeovers**. Questo è particolarmente critico nelle applicazioni in cui OAuth è utilizzato per **scopi di autenticazione**.
Gli attaccanti possono sfruttare questo intercettando il processo di autorizzazione per collegare il proprio account a quello di una vittima, portando a potenziali **account takeovers**. Questo è particolarmente critico nelle applicazioni in cui OAuth è utilizzato per **scopi di autenticazione**.
Esempi reali di questa vulnerabilità sono stati documentati in varie **CTF challenges** e **hacking platforms**, evidenziando le sue implicazioni pratiche. Il problema si estende anche alle integrazioni con servizi di terze parti come **Slack**, **Stripe** e **PayPal**, dove gli attaccanti possono reindirizzare notifiche o pagamenti ai propri account.
@ -160,7 +160,7 @@ Questo perché un **attaccante** potrebbe creare un **applicazione che supporta
### Due link & cookie <a href="#bda5" id="bda5"></a>
Secondo [**questo articolo**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), era possibile far aprire a una vittima una pagina con un **returnUrl** che punta all'host dell'attaccante. Queste informazioni sarebbero state **memorizzate in un cookie (RU)** e in un **passaggio successivo** il **prompt** **chiederà** all'**utente** se desidera concedere l'accesso a quell'host dell'attaccante.
Secondo [**questo articolo**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), era possibile far aprire a una vittima una pagina con un **returnUrl** che punta all'host dell'attaccante. Queste informazioni sarebbero state **memorizzate in un cookie (RU)** e in un **passaggio successivo** il **prompt** **chiederà** all'**utente** se desidera concedere accesso a quell'host dell'attaccante.
Per bypassare questo prompt, era possibile aprire una scheda per avviare il **flusso Oauth** che imposterebbe questo cookie RU utilizzando il **returnUrl**, chiudere la scheda prima che venga mostrato il prompt e aprire una nuova scheda senza quel valore. Quindi, il **prompt non informerà riguardo all'host dell'attaccante**, ma il cookie sarebbe impostato su di esso, quindi il **token sarà inviato all'host dell'attaccante** nella redirezione.
@ -179,7 +179,7 @@ Come [**spiegato in questo video**](https://www.youtube.com/watch?v=n9x7_J_a_7Q)
### Flusso OAuth ROPC - bypass 2 FA <a href="#b440" id="b440"></a>
Secondo [**questo post del blog**](https://cybxis.medium.com/a-bypass-on-gitlabs-login-email-verification-via-oauth-ropc-flow-e194242cad96), questo è un flusso OAuth che consente di accedere a OAuth tramite **nome utente** e **password**. Se durante questo semplice flusso viene restituito un **token** con accesso a tutte le azioni che l'utente può eseguire, allora è possibile bypassare 2FA utilizzando quel token.
Secondo [**questo post del blog**](https://cybxis.medium.com/a-bypass-on-gitlabs-login-email-verification-via-oauth-ropc-flow-e194242cad96), questo è un flusso OAuth che consente di accedere in OAuth tramite **nome utente** e **password**. Se durante questo semplice flusso viene restituito un **token** con accesso a tutte le azioni che l'utente può eseguire, allora è possibile bypassare 2FA utilizzando quel token.
### ATO su pagina web che reindirizza in base a open redirect al referrer <a href="#bda5" id="bda5"></a>

4
src/pentesting-web/xss-cross-site-scripting/other-js-tricks.md
View File

@ -144,7 +144,7 @@ document.body.append(anchor)
// Another way to test
<a href="&#12;javascript:alert(1337)">Test</a>
```
### Fuzzing degli URL
### URL Fuzzing
```javascript
// Heyes, Gareth. JavaScript for hackers: Learn to think like a hacker (pp. 36-37). Kindle Edition.
@ -208,7 +208,7 @@ L'operatore di decremento `--` è anche un'assegnazione. Questo operatore prende
### .call e .apply
Il metodo **`.call`** di una funzione è usato per **eseguire la funzione**.\
Il **primo argomento** che si aspetta per impostazione predefinita è il **valore di `this`** e se **niente** viene fornito, **`window`** sarà quel valore (a meno che non sia **`strict mode`**).
Il **primo argomento** che si aspetta per impostazione predefinita è il **valore di `this`** e se **nulla** viene fornito, **`window`** sarà quel valore (a meno che non sia **`strict mode`**).
```javascript
function test_call() {
console.log(this.value) //baz

4
src/todo/cookies-policy.md
View File

@ -26,7 +26,7 @@ Utilizziamo i cookie sui nostri siti web per i seguenti scopi:
3. Cookie di funzionalità: Questi cookie consentono ai nostri siti web di ricordare le scelte che fai, come la tua lingua o regione, per fornire un'esperienza più personalizzata.
4. Cookie di targeting/pubblicità: Questi cookie vengono utilizzati per fornire annunci pertinenti e comunicazioni di marketing basate sui tuoi interessi, sulla tua cronologia di navigazione e sulle interazioni con i nostri siti web.
Inoltre, le pagine book.hacktricks.wiki e cloud.hacktricks.wiki sono ospitate in Gitbook. Puoi trovare ulteriori informazioni sui cookie di Gitbook in [https://gitbook-1652864889.teamtailor.com/cookie-policy](https://gitbook-1652864889.teamtailor.com/cookie-policy).
Inoltre, le pagine book.hacktricks.wiki e cloud.hacktricks.wiki sono ospitate su Gitbook. Puoi trovare ulteriori informazioni sui cookie di Gitbook in [https://gitbook-1652864889.teamtailor.com/cookie-policy](https://gitbook-1652864889.teamtailor.com/cookie-policy).
### Cookie di terze parti
@ -38,7 +38,7 @@ La maggior parte dei browser web consente di gestire i cookie tramite le loro im
Modifiche a questa Cookies Policy
Potremmo aggiornare questa Cookies Policy di tanto in tanto per riflettere i cambiamenti nelle nostre pratiche o nelle leggi pertinenti. Ti incoraggiamo a rivedere periodicamente questa pagina per le ultime informazioni sulle nostre pratiche relative ai cookie.
Potremmo aggiornare questa Cookies Policy di tanto in tanto per riflettere cambiamenti nelle nostre pratiche o nelle leggi pertinenti. Ti incoraggiamo a rivedere periodicamente questa pagina per le ultime informazioni sulle nostre pratiche relative ai cookie.
### Contattaci

10
src/welcome/hacktricks-values-and-faq.md
View File

@ -10,7 +10,7 @@
> - Dare accesso **GRATUITO** a risorse di **hacking EDUCATIVO** a **TUTTI** su Internet.
> - L'hacking riguarda l'apprendimento, e l'apprendimento dovrebbe essere il più gratuito possibile.
> - Lo scopo di questo libro è servire come una **risorsa educativa** completa.
> - **ARCHIVIARE** tecniche di **hacking** fantastiche che la comunità pubblica dando tutti i **crediti** agli **AUTORI ORIGINALI**.
> - **ARCHIVIARE** tecniche di **hacking** fantastiche che la comunità pubblica dando a tutti gli **AUTORI ORIGINALI** tutti i **crediti**.
> - **Non vogliamo il credito da altre persone**, vogliamo solo archiviare trucchi interessanti per tutti.
> - Scriviamo anche **le nostre ricerche** in HackTricks.
> - In diversi casi scriveremo **in HackTricks un riassunto delle parti importanti** della tecnica e **incoraggeremo il lettore a visitare il post originale** per maggiori dettagli.
@ -102,7 +102,7 @@ Tuttavia, se desideri ancora che il contenuto del tuo blog venga rimosso da Hack
>
> - **Cosa devo fare se trovo contenuto copiato e incollato in HackTricks?**
Diamo sempre **tutti i crediti agli autori originali**. Se trovi una pagina con contenuto copiato e incollato senza la fonte originale citata, faccelo sapere e **lo rimuoveremo**, **aggiungeremo il link prima del testo**, o **lo riscriveremo aggiungendo il link**.
Noi **diamo sempre il credito agli autori originali**. Se trovi una pagina con contenuto copiato e incollato senza la fonte originale citata, faccelo sapere e noi **lo rimuoveremo**, **aggiungeremo il link prima del testo**, o **riscriveremo aggiungendo il link**.
## LICENSE
@ -116,7 +116,7 @@ Copyright © Tutti i diritti riservati, salvo diversa indicazione.
#### Termini Aggiuntivi:
- Contenuto di Terzi: Alcune parti di questo blog/libro possono includere contenuti di altre fonti, come estratti di altri blog o pubblicazioni. L'uso di tali contenuti è fatto secondo i principi di uso equo o con esplicita autorizzazione dai rispettivi titolari dei diritti d'autore. Si prega di fare riferimento alle fonti originali per informazioni specifiche sulla licenza riguardante i contenuti di terzi.
- Contenuto di Terzi: Alcune parti di questo blog/libro possono includere contenuti di altre fonti, come estratti di altri blog o pubblicazioni. L'uso di tali contenuti avviene secondo i principi di uso leale o con esplicita autorizzazione dai rispettivi titolari dei diritti d'autore. Si prega di fare riferimento alle fonti originali per informazioni specifiche sulla licenza riguardante i contenuti di terzi.
- Autorialità: Il contenuto originale redatto da HackTricks è soggetto ai termini di questa licenza. Ti incoraggiamo ad attribuire questo lavoro all'autore quando lo condividi o lo adatti.
#### Esenzioni:
@ -125,7 +125,7 @@ Copyright © Tutti i diritti riservati, salvo diversa indicazione.
Questa licenza non concede alcun diritto di marchio o branding in relazione al contenuto. Tutti i marchi e il branding presenti in questo blog/libro sono di proprietà dei rispettivi proprietari.
**Accedendo o utilizzando HackTricks, accetti di rispettare i termini di questa licenza. Se non sei d'accordo con questi termini, ti preghiamo di non accedere a questo sito web.**
**Accedendo o utilizzando HackTricks, accetti di rispettare i termini di questa licenza. Se non accetti questi termini, ti preghiamo di non accedere a questo sito web.**
## **Disclaimer**
@ -138,6 +138,6 @@ Questa licenza non concede alcun diritto di marchio o branding in relazione al c
>
> L'utente è l'unico responsabile per qualsiasi azione intrapresa sulla base delle informazioni contenute in questo libro e dovrebbe sempre cercare consigli e assistenza professionale quando tenta di implementare una delle tecniche o dei suggerimenti descritti qui.
>
> Utilizzando questo libro, l'utente accetta di liberare gli autori e gli editori da qualsiasi responsabilità e responsabilità per eventuali danni, perdite o danni che possono derivare dall'uso di questo libro o di qualsiasi informazione in esso contenuta.
> Utilizzando questo libro, l'utente accetta di liberare gli autori e gli editori da qualsiasi responsabilità e responsabilità per eventuali danni, perdite o danni che possono derivare dall'uso di questo libro o di qualsiasi informazione contenuta in esso.
{{#include ../banners/hacktricks-training.md}}

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

@ -68,7 +68,7 @@ Se hai solo accesso a un ambiente AD ma non hai credenziali/sessioni, potresti:
- Accedi all'host [**abusando dell'attacco di relay**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
- Raccogli credenziali **esponendo** [**falsi servizi UPnP con evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
- [**OSINT**](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/external-recon-methodology/index.html):
- Estrai nomi utenti/nomi da documenti interni, social media, servizi (principalmente web) all'interno degli ambienti di dominio e anche da fonti pubblicamente disponibili.
- Estrai nomi utenti/nomi da documenti interni, social media, servizi (principalmente web) all'interno degli ambienti di dominio e anche da quelli pubblicamente disponibili.
- Se trovi i nomi completi dei lavoratori dell'azienda, potresti provare diverse **convenzioni di nome utente AD** (**[leggi questo](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Le convenzioni più comuni sono: _NomeCognome_, _Nome.Cognome_, _NamSur_ (3 lettere di ciascuno), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _lettere casuali e 3 numeri casuali_ (abc123).
- Strumenti:
- [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
@ -77,7 +77,7 @@ Se hai solo accesso a un ambiente AD ma non hai credenziali/sessioni, potresti:
### Enumerazione utenti
- **Enumerazione SMB/LDAP anonima:** Controlla le pagine [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) e [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
- **Enumerazione Kerbrute**: Quando viene **richiesto un nome utente non valido**, il server risponderà utilizzando il codice di errore **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, permettendoci di determinare che il nome utente era non valido. I **nomi utente validi** genereranno o il **TGT in una risposta AS-REP** o l'errore _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando che l'utente deve eseguire la pre-autenticazione.
- **Enumerazione Kerbrute**: Quando viene **richiesto un nome utente non valido**, il server risponderà utilizzando il codice di errore **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, permettendoci di determinare che il nome utente era non valido. I **nomi utente validi** genereranno o il **TGT in una risposta AS-REP** o l'errore _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando che l'utente è tenuto a eseguire la pre-autenticazione.
```bash
./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases
@ -112,7 +112,7 @@ Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password
Ok, quindi sai di avere già un nome utente valido ma nessuna password... Allora prova:
- [**ASREPRoast**](asreproast.md): Se un utente **non ha** l'attributo _DONT_REQ_PREAUTH_ puoi **richiedere un messaggio AS_REP** per quell'utente che conterrà alcuni dati crittografati da una derivazione della password dell'utente.
- [**Password Spraying**](password-spraying.md): Proviamo le **password più comuni** con ciascuno degli utenti scoperti, forse qualche utente sta usando una password debole (tieni presente la politica delle password!).
- [**Password Spraying**](password-spraying.md): Proviamo le **password più comuni** con ciascuno degli utenti scoperti, magari qualche utente sta usando una password debole (tieni presente la politica delle password!).
- Nota che puoi anche **spray i server OWA** per cercare di accedere ai server di posta degli utenti.
{{#ref}}
@ -141,7 +141,7 @@ Se puoi **accedere ad altri PC o condivisioni** con l'**utente null o guest** po
## Enumerare Active Directory CON credenziali/sessione
Per questa fase devi avere **compromesso le credenziali o una sessione di un account di dominio valido.** Se hai alcune credenziali valide o una shell come utente di dominio, **dovresti ricordare che le opzioni fornite prima sono ancora opzioni per compromettere altri utenti**.
Per questa fase devi aver **compromesso le credenziali o una sessione di un account di dominio valido.** Se hai alcune credenziali valide o una shell come utente di dominio, **dovresti ricordare che le opzioni fornite prima sono ancora opzioni per compromettere altri utenti**.
Prima di iniziare l'enumerazione autenticata dovresti sapere qual è il **problema del doppio salto Kerberos.**
@ -169,7 +169,7 @@ Per quanto riguarda [**ASREPRoast**](asreproast.md) ora puoi trovare ogni possib
- [**61106960/adPEAS**](https://github.com/61106960/adPEAS)
- **Estrazione di tutti gli utenti di dominio**
È molto facile ottenere tutti i nomi utente del dominio da Windows (`net user /domain` ,`Get-DomainUser` o `wmic useraccount get name,sid`). In Linux, puoi usare: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` o `enum4linux -a -u "user" -p "password" <DC IP>`
È molto facile ottenere tutti i nomi utente del dominio da Windows (`net user /domain`, `Get-DomainUser` o `wmic useraccount get name,sid`). In Linux, puoi usare: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` o `enum4linux -a -u "user" -p "password" <DC IP>`
> Anche se questa sezione di Enumerazione sembra piccola, questa è la parte più importante di tutte. Accedi ai link (principalmente quello di cmd, powershell, powerview e BloodHound), impara come enumerare un dominio e pratica finché non ti senti a tuo agio. Durante una valutazione, questo sarà il momento chiave per trovare la tua strada verso DA o per decidere che non si può fare nulla.
@ -205,7 +205,7 @@ C'è una pagina completa in questo libro su [**escalation dei privilegi locali i
```
### NTML Relay
Se sei riuscito a enumerare l'active directory avrai **più email e una migliore comprensione della rete**. Potresti essere in grado di forzare attacchi [**relay NTML**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**
Se sei riuscito a enumerare l'active directory avrai **più email e una migliore comprensione della rete**. Potresti essere in grado di forzare attacchi di NTML [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**
### **Cerca Credenziali nelle Condivisioni di Computer**
@ -233,16 +233,16 @@ printnightmare.md
**Per le seguenti tecniche un normale utente di dominio non è sufficiente, hai bisogno di privilegi/credenziali speciali per eseguire questi attacchi.**
### Estrazione degli Hash
### Estrazione dell'hash
Speriamo tu sia riuscito a **compromettere qualche account admin locale** utilizzando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) inclusi i relay, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalation dei privilegi localmente](../windows-local-privilege-escalation/index.html).\
Speriamo che tu sia riuscito a **compromettere qualche account admin locale** utilizzando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) inclusi i relay, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\
Poi, è tempo di estrarre tutti gli hash in memoria e localmente.\
[**Leggi questa pagina sui diversi modi per ottenere gli hash.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
### Pass the Hash
**Una volta che hai l'hash di un utente**, puoi usarlo per **impersonarlo**.\
Devi usare qualche **strumento** che **eseguirà** l'**autenticazione NTLM utilizzando** quell'**hash**, **oppure** potresti creare un nuovo **sessionlogon** e **iniettare** quell'**hash** all'interno di **LSASS**, così quando viene eseguita qualsiasi **autenticazione NTLM**, quell'**hash verrà utilizzato.** L'ultima opzione è ciò che fa mimikatz.\
Devi usare qualche **strumento** che **eseguirà** l'**autenticazione NTLM utilizzando** quell'**hash**, **oppure** potresti creare un nuovo **sessionlogon** e **iniettare** quell'**hash** all'interno del **LSASS**, così quando viene eseguita qualsiasi **autenticazione NTLM**, quell'**hash verrà utilizzato.** L'ultima opzione è ciò che fa mimikatz.\
[**Leggi questa pagina per ulteriori informazioni.**](../ntlm/index.html#pass-the-hash)
### Over Pass the Hash/Pass the Key
@ -286,7 +286,7 @@ abusing-ad-mssql.md
Se trovi un oggetto Computer con l'attributo [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) e hai privilegi di dominio nel computer, sarai in grado di estrarre i TGT dalla memoria di ogni utente che accede al computer.\
Quindi, se un **Domain Admin accede al computer**, sarai in grado di estrarre il suo TGT e impersonarlo usando [Pass the Ticket](pass-the-ticket.md).\
Grazie alla delegazione vincolata potresti anche **compromettere automaticamente un Print Server** (speriamo che sia un DC).
Grazie alla delegazione vincolata potresti persino **compromettere automaticamente un Print Server** (speriamo che sia un DC).
{{#ref}}
unconstrained-delegation.md
@ -371,7 +371,7 @@ Una volta ottenuti i privilegi di **Domain Admin** o anche meglio di **Enterpris
### Privesc come Persistenza
Alcune delle tecniche discusse in precedenza possono essere utilizzate per la persistenza.\
Ad esempio, potresti:
Ad esempio potresti:
- Rendere gli utenti vulnerabili a [**Kerberoast**](kerberoast.md)
@ -435,7 +435,7 @@ ad-certificates/domain-persistence.md
### Gruppo AdminSDHolder
L'oggetto **AdminSDHolder** in Active Directory garantisce la sicurezza dei **gruppi privilegiati** (come Domain Admins e Enterprise Admins) applicando una standard **Access Control List (ACL)** su questi gruppi per prevenire modifiche non autorizzate. Tuttavia, questa funzionalità può essere sfruttata; se un attaccante modifica l'ACL di AdminSDHolder per dare accesso completo a un utente normale, quell'utente ottiene un controllo esteso su tutti i gruppi privilegiati. Questa misura di sicurezza, destinata a proteggere, può quindi ritorcersi contro, consentendo accessi non autorizzati a meno che non venga monitorata attentamente.
L'oggetto **AdminSDHolder** in Active Directory garantisce la sicurezza dei **gruppi privilegiati** (come Domain Admins e Enterprise Admins) applicando una standard **Access Control List (ACL)** su questi gruppi per prevenire modifiche non autorizzate. Tuttavia, questa funzionalità può essere sfruttata; se un attaccante modifica l'ACL di AdminSDHolder per dare accesso completo a un utente normale, quell'utente ottiene un controllo esteso su tutti i gruppi privilegiati. Questa misura di sicurezza, destinata a proteggere, può quindi ritorcersi contro, consentendo accessi non autorizzati a meno che non venga monitorata da vicino.
[**Maggiori informazioni sul Gruppo AdminDSHolder qui.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
@ -457,7 +457,7 @@ acl-persistence-abuse/
### Descrittori di Sicurezza
I **descrittori di sicurezza** vengono utilizzati per **memorizzare** i **privilegi** che un **oggetto** ha **su** un **oggetto**. Se puoi **fare** solo **una piccola modifica** nel **descrittore di sicurezza** di un oggetto, puoi ottenere privilegi molto interessanti su quell'oggetto senza dover essere membro di un gruppo privilegiato.
I **descrittori di sicurezza** vengono utilizzati per **memorizzare** i **privilegi** che un **oggetto** ha **su** un **oggetto**. Se riesci a **fare** un **piccolo cambiamento** nel **descrittore di sicurezza** di un oggetto, puoi ottenere privilegi molto interessanti su quell'oggetto senza dover essere membro di un gruppo privilegiato.
{{#ref}}
security-descriptors.md
@ -510,13 +510,13 @@ In uno scenario tipico, se un utente intende accedere a un servizio in un **domi
**Passaggi**:
1. Un **computer client** in **Dominio 1** avvia il processo utilizzando il proprio **hash NTLM** per richiedere un **Ticket Granting Ticket (TGT)** dal proprio **Domain Controller (DC1)**.
1. Un **computer client** nel **Dominio 1** avvia il processo utilizzando il proprio **hash NTLM** per richiedere un **Ticket Granting Ticket (TGT)** dal proprio **Domain Controller (DC1)**.
2. DC1 emette un nuovo TGT se il client viene autenticato con successo.
3. Il client richiede quindi un **inter-realm TGT** da DC1, necessario per accedere alle risorse in **Dominio 2**.
3. Il client richiede quindi un **inter-realm TGT** da DC1, necessario per accedere alle risorse nel **Dominio 2**.
4. L'inter-realm TGT è crittografato con una **chiave di fiducia** condivisa tra DC1 e DC2 come parte della fiducia tra domini bidirezionale.
5. Il client porta l'inter-realm TGT al **Domain Controller (DC2) di Dominio 2**.
6. DC2 verifica l'inter-realm TGT utilizzando la sua chiave di fiducia condivisa e, se valido, emette un **Ticket Granting Service (TGS)** per il server in Dominio 2 a cui il client desidera accedere.
7. Infine, il client presenta questo TGS al server, che è crittografato con l'hash dell'account del server, per ottenere accesso al servizio in Dominio 2.
5. Il client porta l'inter-realm TGT al **Domain Controller (DC2) del Dominio 2**.
6. DC2 verifica l'inter-realm TGT utilizzando la sua chiave di fiducia condivisa e, se valido, emette un **Ticket Granting Service (TGS)** per il server nel Dominio 2 a cui il client desidera accedere.
7. Infine, il client presenta questo TGS al server, che è crittografato con l'hash dell'account del server, per ottenere accesso al servizio nel Dominio 2.
### Diverse fiducia
@ -526,11 +526,11 @@ Se il Dominio A si fida del Dominio B, A è il dominio fiducioso e B è quello f
**Diverse relazioni di fiducia**
- **Fiducia Genitore-Figlio**: Questa è una configurazione comune all'interno della stessa foresta, dove un dominio figlio ha automaticamente una fiducia transitoria bidirezionale con il suo dominio genitore. Essenzialmente, ciò significa che le richieste di autenticazione possono fluire senza problemi tra il genitore e il figlio.
- **Fiducia Genitore-Figlio**: Questa è una configurazione comune all'interno della stessa foresta, dove un dominio figlio ha automaticamente una fiducia bidirezionale transitiva con il suo dominio genitore. Essenzialmente, ciò significa che le richieste di autenticazione possono fluire senza problemi tra il genitore e il figlio.
- **Fiducia Cross-link**: Riferita come "fiducia di collegamento rapido", queste vengono stabilite tra domini figli per accelerare i processi di riferimento. In foreste complesse, i riferimenti di autenticazione devono generalmente viaggiare fino alla radice della foresta e poi giù fino al dominio di destinazione. Creando collegamenti incrociati, il viaggio viene accorciato, il che è particolarmente vantaggioso in ambienti geograficamente dispersi.
- **Fiducia Esterna**: Queste vengono stabilite tra domini diversi e non correlati e sono di natura non transitoria. Secondo la [documentazione di Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), le fiducia esterne sono utili per accedere a risorse in un dominio al di fuori della foresta attuale che non è connesso tramite una fiducia tra foreste. La sicurezza è rafforzata attraverso il filtraggio SID con fiducia esterne.
- **Fiducia Tree-root**: Queste fiducia vengono automaticamente stabilite tra il dominio radice della foresta e un nuovo albero radice aggiunto. Anche se non comunemente incontrate, le fiducia tree-root sono importanti per aggiungere nuovi alberi di dominio a una foresta, consentendo loro di mantenere un nome di dominio unico e garantendo una transitorietà bidirezionale. Maggiori informazioni possono essere trovate nella [guida di Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
- **Fiducia tra Foreste**: Questo tipo di fiducia è una fiducia transitoria bidirezionale tra due domini radice di foresta, imponendo anche il filtraggio SID per migliorare le misure di sicurezza.
- **Fiducia Esterna**: Queste vengono stabilite tra domini diversi e non correlati e sono di natura non transitiva. Secondo la [documentazione di Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), le fiducia esterne sono utili per accedere a risorse in un dominio al di fuori della foresta attuale che non è connesso tramite una fiducia tra foreste. La sicurezza è rafforzata attraverso il filtraggio SID con fiducia esterne.
- **Fiducia Tree-root**: Queste fiducia vengono automaticamente stabilite tra il dominio radice della foresta e un nuovo albero radice aggiunto. Anche se non comunemente incontrate, le fiducia tree-root sono importanti per aggiungere nuovi alberi di dominio a una foresta, consentendo loro di mantenere un nome di dominio unico e garantendo una transitività bidirezionale. Maggiori informazioni possono essere trovate nella [guida di Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
- **Fiducia tra Foreste**: Questo tipo di fiducia è una fiducia bidirezionale transitiva tra due domini radice di foresta, imponendo anche il filtraggio SID per migliorare le misure di sicurezza.
- **Fiducia MIT**: Queste fiducia vengono stabilite con domini Kerberos non Windows, [RFC4120-compliant](https://tools.ietf.org/html/rfc4120). Le fiducia MIT sono un po' più specializzate e si rivolgono a ambienti che richiedono integrazione con sistemi basati su Kerberos al di fuori dell'ecosistema Windows.
#### Altre differenze nelle **relazioni di fiducia**
@ -548,7 +548,7 @@ Se il Dominio A si fida del Dominio B, A è il dominio fiducioso e B è quello f
Gli attaccanti potrebbero accedere alle risorse in un altro dominio attraverso tre meccanismi principali:
- **Appartenenza a Gruppi Locali**: I principali potrebbero essere aggiunti a gruppi locali su macchine, come il gruppo “Amministratori” su un server, concedendo loro un controllo significativo su quella macchina.
- **Appartenenza a Gruppi di Domini Esterni**: I principali possono anche essere membri di gruppi all'interno del dominio esterno. Tuttavia, l'efficacia di questo metodo dipende dalla natura della fiducia e dall'ambito del gruppo.
- **Appartenenza a Gruppi di Domini Stranieri**: I principali possono anche essere membri di gruppi all'interno del dominio straniero. Tuttavia, l'efficacia di questo metodo dipende dalla natura della fiducia e dall'ambito del gruppo.
- **Liste di Controllo di Accesso (ACL)**: I principali potrebbero essere specificati in un **ACL**, in particolare come entità in **ACE** all'interno di un **DACL**, fornendo loro accesso a risorse specifiche. Per coloro che desiderano approfondire la meccanica delle ACL, DACL e ACE, il whitepaper intitolato “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” è una risorsa preziosa.
### Escalation dei privilegi da Figlio a Genitore nella foresta
@ -592,7 +592,7 @@ Per informazioni approfondite, si può esplorare la ricerca su [Bypassing SID Fi
**Compromettere qualsiasi gMSA nella foresta**
Un vettore d'attacco implica il targeting di gMSA privilegiati all'interno del dominio. La chiave KDS Root, essenziale per calcolare le password delle gMSA, è memorizzata all'interno della Configurazione NC. Con privilegi SYSTEM su qualsiasi DC, è possibile accedere alla chiave KDS Root e calcolare le password per qualsiasi gMSA nella foresta.
Un vettore d'attacco coinvolge il targeting di gMSA privilegiati all'interno del dominio. La chiave KDS Root, essenziale per calcolare le password delle gMSA, è memorizzata all'interno della Configurazione NC. Con privilegi SYSTEM su qualsiasi DC, è possibile accedere alla chiave KDS Root e calcolare le password per qualsiasi gMSA nella foresta.
Un'analisi dettagliata può essere trovata nella discussione su [Golden gMSA Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent).
@ -604,7 +604,7 @@ Ulteriori letture sono disponibili su [Schema Change Trust Attacks](https://impr
**Da DA a EA con ADCS ESC5**
La vulnerabilità ADCS ESC5 mira al controllo sugli oggetti di Public Key Infrastructure (PKI) per creare un modello di certificato che consente l'autenticazione come qualsiasi utente all'interno della foresta. Poiché gli oggetti PKI risiedono nella Configurazione NC, compromettere un DC child scrivibile consente l'esecuzione di attacchi ESC5.
La vulnerabilità ADCS ESC5 mira al controllo sugli oggetti della Public Key Infrastructure (PKI) per creare un modello di certificato che consente l'autenticazione come qualsiasi utente all'interno della foresta. Poiché gli oggetti PKI risiedono nella Configurazione NC, compromettere un DC child scrivibile consente l'esecuzione di attacchi ESC5.
Maggiori dettagli su questo possono essere letti in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). In scenari privi di ADCS, l'attaccante ha la capacità di impostare i componenti necessari, come discusso in [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).
@ -663,7 +663,7 @@ rdp-sessions-abuse.md
### **Autenticazione Selettiva:**
- Per le fiducie inter-foresta, l'uso dell'Autenticazione Selettiva garantisce che gli utenti delle due foreste non siano autenticati automaticamente. Invece, sono necessarie autorizzazioni esplicite affinché gli utenti accedano ai domini e ai server all'interno del dominio o della foresta fiduciosa.
- Per le fiducie inter-foresta, l'uso dell'Autenticazione Selettiva garantisce che gli utenti delle due foreste non siano autenticati automaticamente. Invece, sono necessarie autorizzazioni esplicite per gli utenti per accedere ai domini e ai server all'interno del dominio o della foresta fiduciosa.
- È importante notare che queste misure non proteggono contro lo sfruttamento del Contesto di Nominazione di Configurazione (NC) scrivibile o attacchi all'account di fiducia.
[**Ulteriori informazioni sulle fiducie di dominio in ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)