---

avdroot porta un AVD da un avvio a freddo a una shell di root funzionante con un solo comando. Tutto avviene sull'host: il ramdisk viene decompresso, riscritto in modo che l'init di Magisk sostituisca /init, e ricompresso. La creazione dell'immagine non richiede alcuno script shell, nessun busybox, nessun magiskboot e nessuna esecuzione di codice all'interno dell'emulatore.``` $ avdroot root ==> Target Pixel_10_Pro_XL (the only AVD) ==> Preparing Magisk's environment Magisk's files are not unpacked yet; writing them for 31.0 now ok 14 files written for Magisk 31.0, before the restart that will use them ==> Patching preinit device: vdd1 (read from the running emulator) ==> Restarting the emulator booting cold, because a snapshot would restore the pre-patch ramdisk ==> Installing the Magisk app ok installed com.topjohnwu.magisk (Magisk 31.0) ==> Granting su to the adb shell ok uid 2000 allowed ==> Verifying root ok Magisk 31.0:MAGISK:R is running ok su grants root

root: uid=0(root) gid=0(root) groups=0(root) context=u:r:magisk:s0

## Indice

- [Perché un altro](#why-another-one)
- [Installazione](#install)
- [Avvio rapido](#quick-start)
- [Comandi](#commands)
- [Come funziona](#how-it-works)
- [Scegliere una release di Magisk](#choose-a-magisk-release)
- [Trappole gestite da questo strumento](#traps-this-tool-handles)
- [Catturare HTTPS da Chrome](#capturing-https-from-chrome)
- [Supporto piattaforme](#platform-support)
- [Lingua di output](#output-language)
- [Sviluppo](#development)
- [Crediti e licenza](#credits-and-licence)

## Perché un altro

[rootAVD](https://github.com/newbit1/rootAVD) è stato il pioniere di questa tecnica e rimane ancora il
riferimento, ma non si è tenuto al passo con le recenti release di Android e
Magisk. Eseguirlo su un AVD con Android 17 mostra chiaramente i problemi,
e ognuno di essi è risolto qui:

| comportamento di rootAVD | avdroot |
|---|---|
| Richiede `bash`, `busybox`, `unzip`, `xxd`, `strings`, `dd`, `cpio` e GNU `stat`/`sed` (che differiscono su macOS) | Un singolo binario Go statico. cpio, LZ4, gzip e xz sono tutti implementati in-process |
| Copia lo script più i binari nell'emulatore e si esegue al suo interno | Costruisce l'immagine interamente sull'host |
| Esegue il backup di `ramdisk.img` a ogni esecuzione, quindi dopo la prima patch il backup "pristine" è esso stesso patchato e `restore` non può tornare allo stato originale | Esegue il backup una sola volta, non lo sovrascrive mai e avvisa se un backup esistente risulta patchato |
| Applica la patch per il vecchio layout `magisk32`/`magisk64` di Magisk | Implementa Magisk 26+ (`magiskinit`, `magisk`, `init-ld`, `.backup/.rmlist`) |
| Richiede che il percorso del ramdisk venga incollato come argomento | Rileva l'SDK, gli AVD e le immagini, con `--sdk`/`--avd-home` per sovrascrivere |
| Riavvia incondizionatamente e spera | Forza un cold boot e verifica che `su` restituisca effettivamente `uid=0` |

## Installazione

**Binari precompilati** — prendi l'archivio per la tua piattaforma dalle
[Releases](https://github.com/ejfkdev/avdroot/releases):```sh
tar -xzf avdroot_linux_amd64.tar.gz
chmod +x avdroot_linux_amd64
sudo mv avdroot_linux_amd64 /usr/local/bin/avdroot

Gli archivi Windows e macOS contengono un singolo eseguibile; su macOS potrebbe essere necessario rimuovere l'attributo di quarantena:```sh xattr -d com.apple.quarantine avdroot_darwin_arm64

Ogni release pubblica anche `SHA256SUMS.txt`:```sh
sha256sum -c SHA256SUMS.txt --ignore-missing

Con Go (1.24 o successivo):```sh go install github.com/ejfkdev/avdroot@latest

Go 1.24 è il minimo perché le toolchain precedenti non emettono alcun comando di caricamento `LC_UUID`,
e il `dyld` di macOS 26 rifiuta di avviare un simile binario. Anche Go 1.21 e 1.22 marcano
`minos 26.0`, quindi falliscono su entrambi i fronti.

**Dal sorgente:**```sh
git clone https://github.com/ejfkdev/avdroot
cd avdroot
make build          # host binary
make all            # every release target into dist/

Hai inoltre bisogno di un Android SDK con adb e l'emulatore, e un'immagine di sistema google_apis o AOSP. Le immagini del Play Store non possono essere rootate in questo modo: rifiutano adb root, quindi patch e root le rifiutano immediatamente invece di fallire diversi minuti dopo.

Avvio rapido```sh

avdroot list # what exists, and what state it is in avdroot root # patch, restart, install the app, grant su, verify

That è tutto. `root` non necessita di un nome AVD quando ne esiste solo uno, chiede
conferma una volta sola e salta del tutto la domanda quando stdin non è un terminale:```sh
avdroot root Pixel_10_Pro_XL --yes     # named AVD, unattended

Se preferisci farlo per passaggi:```sh avdroot patch # patch only; the emulator need not be running avdroot patch --dry-run # show what would change, write nothing

restart the emulator yourself, then

avdroot install && avdroot verify

Per annullare:```sh
avdroot restore                # restores ramdisk.img.backup

Comandi

Comando	Descrizione
avdroot root [target]	Applica la patch, riavvia, installa, concede su, verifica — senza interazione
avdroot patch [target]	Applica la patch solo al ramdisk; chiede prima di scrivere
avdroot restore [target]	Ripristina da ramdisk.img.backup
avdroot list	AVD, immagini di sistema e il loro stato di patch
avdroot status [target]	Dettagli per un target, incluso il dispositivo preinit
avdroot verify [target]	Verifica che Magisk sia in esecuzione e che su restituisca uid=0
avdroot install	Installa l'app Magisk nell'emulatore in esecuzione
avdroot magisk info	Quale installer verrebbe usato e cosa supporta
avdroot magisk fetch	Scarica una release (--list, --version, --prerelease)
avdroot trust-chrome	Fa accettare a Chrome una CA di intercettazione (--cert, --clear)
avdroot doctor	Spiega come è stato individuato ogni percorso

Un target è un nome di AVD, un percorso di un'immagine di sistema o un percorso a un ramdisk.img. avdroot <command> --help mostra esempi per ciascuno.

Flag globali

Si applicano a ogni comando: