---

O avdroot leva um AVD de uma inicialização a frio até um shell root funcional com um único comando. Tudo acontece no host: o ramdisk é descompactado, reescrito para que o init do Magisk substitua o /init, e recomprimido. A construção da imagem não precisa de shell script, nem busybox, nem magiskboot, e nem execução de código dentro do emulador.``` $ 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

## Índice

- [Por que outro](#why-another-one)
- [Instalação](#install)
- [Início rápido](#quick-start)
- [Comandos](#commands)
- [Como funciona](#how-it-works)
- [Escolha uma versão do Magisk](#choose-a-magisk-release)
- [Armadilhas que esta ferramenta trata](#traps-this-tool-handles)
- [Capturando HTTPS do Chrome](#capturing-https-from-chrome)
- [Suporte de plataforma](#platform-support)
- [Idioma de saída](#output-language)
- [Desenvolvimento](#development)
- [Créditos e licença](#credits-and-licence)

## Por que outro

[rootAVD](https://github.com/newbit1/rootAVD) foi pioneiro nisso e ainda é a
referência para a técnica, mas não acompanhou as versões recentes do Android e
do Magisk. Executá-lo contra um AVD do Android 17 mostra os problemas
claramente, e cada um é corrigido aqui:

| comportamento do rootAVD | avdroot |
|---|---|
| Requer `bash`, `busybox`, `unzip`, `xxd`, `strings`, `dd`, `cpio` e GNU `stat`/`sed` (que diferem no macOS) | Um único binário Go estático. cpio, LZ4, gzip e xz são todos implementados em processo |
| Copia o script mais os binários para o emulador e executa a si mesmo lá | Constrói a imagem inteiramente no host |
| Faz backup do `ramdisk.img` a cada execução, então após o primeiro patch o backup "impecável" já está patchado e `restore` não consegue retornar ao estado original | Faz backup uma vez, nunca sobrescreve, e avisa se um backup existente acabar sendo patchado |
| Patcha para o layout antigo `magisk32`/`magisk64` do Magisk | Implementa o Magisk 26+ (`magiskinit`, `magisk`, `init-ld`, `.backup/.rmlist`) |
| Precisa do caminho do ramdisk colado como argumento | Descobre o SDK, AVDs e imagens, com `--sdk`/`--avd-home` para sobrescrever |
| Reinicia incondicionalmente e torce | Força um cold boot e verifica que `su` realmente retorna `uid=0` |

## Instalação

**Binários pré-compilados** — pegue o arquivo para sua plataforma em
[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

Arquivos compactados do Windows e macOS contêm um único executável; no macOS, pode ser necessário remover o atributo de quarentena:```sh xattr -d com.apple.quarantine avdroot_darwin_arm64

Cada release também publica `SHA256SUMS.txt`:```sh
sha256sum -c SHA256SUMS.txt --ignore-missing

Com Go (1.24 ou mais recente):```sh go install github.com/ejfkdev/avdroot@latest

Go 1.24 é o mínimo porque toolchains anteriores não emitem o comando de carga `LC_UUID`,
e o `dyld` do macOS 26 recusa-se a iniciar tal binário. Go 1.21 e 1.22 também marcam
`minos 26.0`, portanto falham em ambos os critérios.

**A partir do código-fonte:**```sh
git clone https://github.com/ejfkdev/avdroot
cd avdroot
make build          # host binary
make all            # every release target into dist/

Você também precisa de um Android SDK com adb e o emulador, e uma imagem de sistema google_apis ou AOSP. Imagens da Play Store não podem ser rooteadas dessa forma: elas recusam adb root, então patch e root as rejeitam imediatamente em vez de falhar vários minutos depois.

Início rápido```sh

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

Isso é tudo. `root` não precisa de nome de AVD quando existe apenas um, pede
confirmação uma vez e ignora a pergunta completamente quando stdin não é um terminal:```sh
avdroot root Pixel_10_Pro_XL --yes     # named AVD, unattended

Se você preferir fazer isso em etapas:```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

Para desfazer:```sh
avdroot restore                # restores ramdisk.img.backup

Comandos

Comando	Descrição
avdroot root [target]	Aplicar patch, reiniciar, instalar, conceder su, verificar — sem interação
avdroot patch [target]	Aplicar patch apenas ao ramdisk; pergunta antes de escrever
avdroot restore [target]	Restaurar a partir de ramdisk.img.backup
avdroot list	AVDs, imagens de sistema e o respetivo estado de patch
avdroot status [target]	Detalhes de um alvo, incluindo o dispositivo preinit
avdroot verify [target]	Verificar que o Magisk é executado e que su devolve uid=0
avdroot install	Instalar a aplicação Magisk no emulador em execução
avdroot magisk info	Qual instalador seria usado, e o que suporta
avdroot magisk fetch	Descarregar uma release (--list, --version, --prerelease)
avdroot trust-chrome	Fazer o Chrome aceitar uma CA de interceção (--cert, --clear)
avdroot doctor	Explicar como cada caminho foi localizado

Um alvo é um nome de AVD, um caminho de imagem de sistema, ou um caminho para um ramdisk.img. avdroot <command> --help mostra exemplos para cada um.

Flags globais

Estas aplicam-se a todos os comandos: