Translated ['src/mobile-pentesting/ios-pentesting/ios-pentesting-without

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
 

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” <https://portswigger.net/research/http2>
+* Bishop Fox – “h2c Smuggling: request smuggling via HTTP/2 clear-text” <https://bishopfox.com/blog/h2c-smuggling-request>
 
 {{#include ../../banners/hacktricks-training.md}}