From bae025e3d74c4a410aebe53e02bbaa77505bf57a Mon Sep 17 00:00:00 2001 From: Translator Date: Sat, 12 Jul 2025 18:08:13 +0000 Subject: [PATCH] Translated ['src/mobile-pentesting/ios-pentesting/ios-pentesting-without --- .../ios-pentesting-without-jailbreak.md | 24 ++--- .../request-smuggling-in-http-2-downgrades.md | 97 ++++++++++++++++++- 2 files changed, 107 insertions(+), 14 deletions(-) diff --git a/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md b/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md index e5ec30aa3..af70a4595 100644 --- a/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md +++ b/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md @@ -8,20 +8,20 @@ Le applicazioni firmate con l'**entitlement `get_task_allow`** consentono alle a Tuttavia, non è così semplice come estrarre l'IPA, firmarlo nuovamente con l'entitlement e ricaricarlo sul tuo dispositivo. Questo a causa della protezione FairPlay. Quando la firma dell'app cambia, la chiave DRM (Digital Rights Management) è **annullata e l'app non funzionerà**. -Con un vecchio dispositivo jailbroken, è possibile installare l'IPA, **decrittarlo utilizzando il tuo strumento preferito** (come Iridium o frida-ios-dump) e estrarlo dal dispositivo. Anche se, se possibile, è consigliato chiedere semplicemente al cliente per l'IPA decrittato. +Con un vecchio dispositivo jailbroken, è possibile installare l'IPA, **decrittarlo utilizzando il tuo strumento preferito** (come Iridium o frida-ios-dump) e estrarlo di nuovo dal dispositivo. Anche se, se possibile, è consigliato chiedere semplicemente al cliente per l'IPA decrittato. ## Ottenere l'IPA decrittato ### Ottienilo da Apple -1. Installa l'app da pentestare sull'iPhone +1. Installa l'app da pentest nell'iPhone 2. Installa e avvia [Apple Configurator](https://apps.apple.com/au/app/apple-configurator/id1037126344?mt=12) sul tuo macos 3. Apri `Terminal` sul tuo Mac e cd a `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`. L'IPA apparirà in questa cartella più tardi. 4. Dovresti vedere il tuo dispositivo iOS. Fai doppio clic su di esso, quindi clicca su Aggiungi + → App dalla barra dei menu in alto. 5. Dopo aver cliccato su Aggiungi, Configurator scaricherà l'IPA da Apple e tenterà di inviarlo al tuo dispositivo. Se hai seguito la mia raccomandazione precedente e hai già installato l'IPA, apparirà un messaggio che ti chiede di reinstallare l'app. 6. L'IPA dovrebbe essere scaricato all'interno di `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps` da dove puoi prenderlo. -Controlla [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed) per ulteriori informazioni dettagliate su questo processo. +Controlla [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed) per informazioni più dettagliate su questo processo. ### Decrittazione dell'app @@ -33,7 +33,7 @@ unzip redacted.ipa -d unzipped ``` Controlla il `Info.plist` per la versione minima supportata e se il tuo dispositivo è più vecchio di quella, modifica il valore affinché sia supportato. -Comprimi di nuovo l'IPA: +Zip di nuovo l'IPA: ```bash cd unzipped zip -r ../no-min-version.ipa * @@ -42,14 +42,14 @@ Quindi, installa l'IPA ad esempio con: ```bash ideviceinstaller -i no-min-version.ipa -w ``` -Nota che potresti aver bisogno di **AppSync Unified tweak** da Cydia per prevenire eventuali errori di `invalid signature`. +Nota che potresti aver bisogno del **tweak AppSync Unified** da Cydia per prevenire eventuali errori di `invalid signature`. -Una volta installato, puoi utilizzare **Iridium tweak** da Cydia per ottenere l'IPA decrittografato. +Una volta installato, puoi utilizzare il **tweak Iridium** da Cydia per ottenere l'IPA decrittografato. ### Patch entitlements & re-sign -Per ri-firmare l'applicazione con il diritto `get-task-allow`, ci sono diversi strumenti disponibili come `app-signer`, `codesign` e `iResign`. `app-signer` ha un'interfaccia molto user-friendly che consente di ri-firmare molto facilmente un file IPA indicando l'IPA da ri-firmare, per **mettere `get-task-allow`** e il certificato e il profilo di provisioning da utilizzare. +Per ri-firmare l'applicazione con il diritto `get-task-allow`, ci sono diversi strumenti disponibili come `app-signer`, `codesign` e `iResign`. `app-signer` ha un'interfaccia molto user-friendly che consente di ri-firmare facilmente un file IPA indicando l'IPA da ri-firmare, per **mettere `get-task-allow`** e il certificato e il profilo di provisioning da utilizzare. Per quanto riguarda i certificati e i profili di firma, Apple offre **profili di firma per sviluppatori gratuiti** per tutti gli account tramite Xcode. Basta creare un'app e configurarne uno. Quindi, configura l'**iPhone per fidarsi delle app degli sviluppatori** navigando su `Impostazioni` → `Privacy e Sicurezza`, e clicca su `Modalità Sviluppatore`. @@ -67,11 +67,11 @@ Dall'iOS 16 Apple ha introdotto la **Modalità Sviluppatore**: qualsiasi binario 2. Naviga su **Impostazioni → Privacy e Sicurezza → Modalità Sviluppatore** e attivala. 3. Il dispositivo si riavvierà; dopo aver inserito il codice di accesso ti verrà chiesto di **Attivare** la Modalità Sviluppatore. -La Modalità Sviluppatore rimane attiva fino a quando non la disabiliti o non ripristini il telefono, quindi questo passaggio deve essere eseguito solo una volta per dispositivo. [La documentazione Apple](https://developer.apple.com/documentation/xcode/enabling-developer-mode-on-a-device) spiega le implicazioni di sicurezza. +La Modalità Sviluppatore rimane attiva fino a quando non la disabiliti o non ripristini il telefono, quindi questo passaggio deve essere eseguito solo una volta per dispositivo. [La documentazione di Apple](https://developer.apple.com/documentation/xcode/enabling-developer-mode-on-a-device) spiega le implicazioni di sicurezza. ### Opzioni moderne di sideloading -Ora ci sono diversi modi maturi per sideloadare e mantenere le IPA ri-firmate aggiornate senza un jailbreak: +Ora ci sono diversi modi maturi per sideloadare e mantenere aggiornate le IPA ri-firmate senza un jailbreak: | Strumento | Requisiti | Punti di forza | Limitazioni | |-----------|-----------|----------------|-------------| @@ -94,7 +94,7 @@ Recenti versioni di Frida (>=16) gestiscono automaticamente l'autenticazione dei ### Analisi dinamica automatizzata con MobSF (senza jailbreak) -[MobSF](https://mobsf.github.io/Mobile-Security-Framework-MobSF/) può strumentare un IPA firmato da sviluppatore su un dispositivo reale utilizzando la stessa tecnica (`get_task_allow`) e fornisce un'interfaccia web con browser di filesystem, cattura del traffico e console Frida【】. Il modo più veloce è eseguire MobSF in Docker e poi collegare il tuo iPhone tramite USB: +[MobSF](https://mobsf.github.io/Mobile-Security-Framework-MobSF/) può strumentare un IPA firmato da sviluppatore su un dispositivo reale utilizzando la stessa tecnica (`get_task_allow`) e fornisce un'interfaccia web con browser di filesystem, cattura del traffico e console Frida【†L2-L3】. Il modo più veloce è eseguire MobSF in Docker e poi collegare il tuo iPhone tramite USB: ```bash docker pull opensecurity/mobile-security-framework-mobsf:latest docker run -p 8000:8000 --privileged \ @@ -104,10 +104,10 @@ opensecurity/mobile-security-framework-mobsf:latest ``` MobSF distribuirà automaticamente il binario, abiliterà un server Frida all'interno della sandbox dell'app e genererà un report interattivo. -### iOS 17 e avvertenze sulla modalità Lockdown +### iOS 17 & avvertenze sulla modalità Lockdown * **Modalità Lockdown** (Impostazioni → Privacy e Sicurezza) blocca il linker dinamico dal caricare librerie dinamiche non firmate o firmate esternamente. Quando si testano dispositivi che potrebbero avere questa modalità abilitata, assicurati che sia **disabilitata** o le tue sessioni Frida/objection termineranno immediatamente. -* L'Autenticazione dei Puntatori (PAC) è applicata a livello di sistema sui dispositivi A12+. Frida ≥16 gestisce in modo trasparente la rimozione del PAC: basta mantenere aggiornati sia *frida-server* che la toolchain Python/CLI quando viene rilasciata una nuova versione principale di iOS. +* L'Autenticazione del Puntatore (PAC) è applicata a livello di sistema sui dispositivi A12+. Frida ≥16 gestisce in modo trasparente la rimozione del PAC: basta mantenere aggiornati sia *frida-server* che la toolchain Python/CLI quando viene rilasciata una nuova versione principale di iOS. ## Riferimenti diff --git a/src/pentesting-web/http-request-smuggling/request-smuggling-in-http-2-downgrades.md b/src/pentesting-web/http-request-smuggling/request-smuggling-in-http-2-downgrades.md index 4ff7f6036..7861b9137 100644 --- a/src/pentesting-web/http-request-smuggling/request-smuggling-in-http-2-downgrades.md +++ b/src/pentesting-web/http-request-smuggling/request-smuggling-in-http-2-downgrades.md @@ -1,7 +1,100 @@ -# Richiesta di Smuggling nei Downgrade HTTP/2 +# Request Smuggling in HTTP/2 Downgrades {{#include ../../banners/hacktricks-training.md}} -**Controlla il post [https://portswigger.net/research/http-2-downgrades](https://portswigger.net/research/http-2-downgrades)** +HTTP/2 è generalmente considerato immune al classic request-smuggling perché la lunghezza di ogni frame DATA è esplicita. **Quella protezione scompare non appena un proxy front-end “downgrada” la richiesta a HTTP/1.x prima di inoltrarla a un back-end**. Nel momento in cui due parser diversi (il front-end HTTP/2 e il back-end HTTP/1) cercano di concordare su dove una richiesta finisce e la successiva inizia, tutti i vecchi trucchi di desync tornano – più alcuni nuovi. + +--- +## Perché avvengono i downgrade + +1. I browser parlano già HTTP/2, ma gran parte dell'infrastruttura legacy di origine comprende ancora solo HTTP/1.1. +2. I reverse-proxy (CDN, WAF, load-balancer) quindi terminano TLS + HTTP/2 al confine e **riscrivono ogni richiesta come HTTP/1.1** per l'origine. +3. Il passaggio di traduzione deve creare *entrambi* gli header `Content-Length` **e/o** `Transfer-Encoding: chunked` in modo che l'origine possa determinare la lunghezza del corpo. + +Ogni volta che il front-end si fida della lunghezza del frame HTTP/2 **ma** il back-end si fida di CL o TE, un attaccante può costringerli a non essere d'accordo. + +--- +## Due classi primitive dominanti + +| Variante | Lunghezza front-end | Lunghezza back-end | Payload tipico | +|---------|---------------------|-------------------|-----------------| +| **H2.TE** | Frame HTTP/2 | `Transfer-Encoding: chunked` | Includere un corpo di messaggio chunked extra il cui finale `0\r\n\r\n` *non* viene inviato, quindi il back-end attende la “prossima” richiesta fornita dall'attaccante. | +| **H2.CL** | Frame HTTP/2 | `Content-Length` | Inviare un CL *più piccolo* rispetto al corpo reale, quindi il back-end legge oltre il confine nella richiesta successiva. | + +> Questi sono identici nello spirito ai classici TE.CL / CL.TE, solo con HTTP/2 che sostituisce uno dei parser. + +--- +## Identificare una catena di downgrade + +1. Usa **ALPN** in un handshake TLS (`openssl s_client -alpn h2 -connect host:443`) o **curl**: +```bash +curl -v --http2 https://target +``` +Se appare `* Using HTTP2`, il confine parla H2. +2. Invia una richiesta CL/TE deliberatamente malformata *sopra* HTTP/2 (Burp Repeater ora ha un menu a discesa per forzare HTTP/2). Se la risposta è un errore HTTP/1.1 come `400 Bad chunk`, hai la prova che il confine ha convertito il traffico per un parser HTTP/1 a valle. + +--- +## Flusso di sfruttamento (esempio H2.TE) +```http +:method: POST +:path: /login +:scheme: https +:authority: example.com +content-length: 13 # ignored by the edge +transfer-encoding: chunked + +5;ext=1\r\nHELLO\r\n +0\r\n\r\nGET /admin HTTP/1.1\r\nHost: internal\r\nX: X +``` +1. Il **front-end** legge esattamente 13 byte (`HELLO\r\n0\r\n\r\nGE`), pensa che la richiesta sia finita e inoltra tanto all'origine. +2. Il **back-end** si fida dell'intestazione TE, continua a leggere fino a vedere il *secondo* `0\r\n\r\n`, consumando così il prefisso della seconda richiesta dell'attaccante (`GET /admin …`). +3. Il resto (`GET /admin …`) è trattato come una *nuova* richiesta in coda dietro quella della vittima. + +Sostituisci la richiesta smuggled con: +* `POST /api/logout` per forzare la fissazione della sessione +* `GET /users/1234` per rubare una risorsa specifica della vittima + +--- +## h2c smuggling (upgrade in chiaro) + +Uno studio del 2023 ha mostrato che se un front-end passa l'intestazione HTTP/1.1 `Upgrade: h2c` a un back-end che supporta HTTP/2 in chiaro, un attaccante può tunnelare *frame* HTTP/2 *raw* attraverso un edge che ha convalidato solo HTTP/1.1. Questo bypassa la normalizzazione delle intestazioni, le regole WAF e persino la terminazione TLS. + +Requisiti chiave: +* L'edge inoltra **entrambi** `Connection: Upgrade` e `Upgrade: h2c` invariati. +* L'origine incrementa a HTTP/2 e mantiene la semantica di riutilizzo della connessione che consente l'accodamento delle richieste. + +La mitigazione è semplice: rimuovere o hard-codificare l'intestazione `Upgrade` all'edge tranne che per i WebSocket. + +--- +## CVE reali notevoli (2022-2025) + +* **CVE-2023-25690** – Le regole di riscrittura mod_proxy di Apache HTTP Server potrebbero essere concatenate per la divisione e lo smuggling delle richieste. (risolto in 2.4.56) +* **CVE-2023-25950** – Smuggling di richieste/riposte in HAProxy 2.7/2.6 quando il parser HTX gestiva in modo errato le richieste in pipeline. +* **CVE-2022-41721** – Go `MaxBytesHandler` ha causato che i byte del corpo rimanenti venissero analizzati come frame **HTTP/2**, abilitando lo smuggling cross-protocol. + +--- +## Strumenti + +* **Burp Request Smuggler** – dalla versione v1.26 testa automaticamente H2.TE/H2.CL e il supporto ALPN nascosto. Abilita “HTTP/2 probing” nelle opzioni dell'estensione. +* **h2cSmuggler** – PoC Python di Bishop Fox per automatizzare l'attacco di upgrade in chiaro: +```bash +python3 h2csmuggler.py -u https://target -x 'GET /admin HTTP/1.1\r\nHost: target\r\n\r\n' +``` +* **curl**/`hyper` – creazione di payload manuali: `curl --http2-prior-knowledge -X POST --data-binary @payload.raw https://target`. + +--- +## Misure difensive + +1. **HTTP/2 end-to-end** – eliminare completamente la traduzione di downgrade. +2. **Fonte unica di verità sulla lunghezza** – quando si effettua il downgrade, *generare sempre* un valido `Content-Length` **e** **rimuovere** eventuali intestazioni `Content-Length`/`Transfer-Encoding` fornite dall'utente. +3. **Normalizzare prima della rotta** – applicare la sanificazione delle intestazioni *prima* della logica di routing/riserve. +4. **Isolamento della connessione** – non riutilizzare le connessioni TCP del back-end tra gli utenti; “una richiesta per connessione” sconfigge gli exploit basati su coda. +5. **Rimuovere `Upgrade` a meno che non sia WebSocket** – previene il tunneling h2c. + +--- +## Riferimenti + +* PortSwigger Research – “HTTP/2: The Sequel is Always Worse” +* Bishop Fox – “h2c Smuggling: request smuggling via HTTP/2 clear-text” {{#include ../../banners/hacktricks-training.md}}