---

avdroot lleva un AVD desde un arranque en frío hasta un shell con root funcional con un solo comando. Todo ocurre en el host: el ramdisk se descomprime, se reescribe para que el init de Magisk reemplace /init, y se recomprime. Construir la imagen no necesita script de shell, ni busybox, ni magiskboot, ni ejecución de código dentro del 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

## Tabla de contenidos

- [Por qué otro más](#why-another-one)
- [Instalación](#install)
- [Inicio rápido](#quick-start)
- [Comandos](#commands)
- [Cómo funciona](#how-it-works)
- [Elegir una versión de Magisk](#choose-a-magisk-release)
- [Trampas que esta herramienta maneja](#traps-this-tool-handles)
- [Capturar HTTPS desde Chrome](#capturing-https-from-chrome)
- [Soporte de plataformas](#platform-support)
- [Idioma de salida](#output-language)
- [Desarrollo](#development)
- [Créditos y licencia](#credits-and-licence)

## Por qué otro más

[rootAVD](https://github.com/newbit1/rootAVD) fue pionero en esto y sigue siendo la
referencia para la técnica, pero no se ha mantenido al día con las versiones recientes de Android y
Magisk. Ejecutarlo contra un AVD de Android 17 muestra los problemas
claramente, y cada uno se corrige aquí:

| Comportamiento de rootAVD | avdroot |
|---|---|
| Requiere `bash`, `busybox`, `unzip`, `xxd`, `strings`, `dd`, `cpio`, y GNU `stat`/`sed` (que difieren en macOS) | Un único binario estático de Go. cpio, LZ4, gzip y xz están todos implementados en proceso |
| Copia el script más los binarios dentro del emulador y se ejecuta a sí mismo allí | Construye la imagen completamente en el host |
| Hace copia de seguridad de `ramdisk.img` en cada ejecución, por lo que tras el primer parche la copia de seguridad "prístina" ya está parcheada y `restore` no puede volver al estado original | Hace copia de seguridad una vez, nunca sobrescribe, y advierte si una copia de seguridad existente resulta estar parcheada |
| Parchea para el antiguo diseño `magisk32`/`magisk64` de Magisk | Implementa Magisk 26+ (`magiskinit`, `magisk`, `init-ld`, `.backup/.rmlist`) |
| Necesita que la ruta del ramdisk se pegue como argumento | Descubre el SDK, los AVDs y las imágenes, con `--sdk`/`--avd-home` para sobrescribir |
| Reinicia incondicionalmente y espera que funcione | Fuerza un arranque en frío y verifica que `su` realmente devuelva `uid=0` |

## Instalación

**Binarios precompilados** — toma el archivo para tu plataforma desde
[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

Los archivos de Windows y macOS contienen un único ejecutable; en macOS es posible que necesites eliminar el atributo de cuarentena:```sh xattr -d com.apple.quarantine avdroot_darwin_arm64

Cada versión también publica `SHA256SUMS.txt`:```sh
sha256sum -c SHA256SUMS.txt --ignore-missing

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

Go 1.24 es el mínimo porque las cadenas de herramientas anteriores no emiten el comando de carga `LC_UUID`, y el `dyld` de macOS 26 se niega a lanzar dicho binario. Go 1.21 y 1.22 también marcan `minos 26.0`, por lo que fallan en ambos aspectos.

**Desde el código fuente:**```sh
git clone https://github.com/ejfkdev/avdroot
cd avdroot
make build          # host binary
make all            # every release target into dist/

También necesitas un Android SDK con adb y el emulador, y una imagen de sistema google_apis o AOSP. Las imágenes de Play Store no se pueden rootear de esta manera: rechazan adb root, por lo que patch y root las rechazan de inmediato en lugar de fallar varios minutos después.

Inicio rápido```sh

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

Eso es todo. `root` no necesita un nombre de AVD cuando solo existe uno, pide
confirmación una vez, y omite la pregunta por completo cuando stdin no es un terminal:```sh
avdroot root Pixel_10_Pro_XL --yes     # named AVD, unattended

Si prefieres hacerlo por pasos:```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 deshacer:```sh
avdroot restore                # restores ramdisk.img.backup

Comandos

Comando	Descripción
avdroot root [target]	Parchear, reiniciar, instalar, otorgar su, verificar — sin intervención
avdroot patch [target]	Parchear solo el ramdisk; pregunta antes de escribir
avdroot restore [target]	Restaurar desde ramdisk.img.backup
avdroot list	AVDs, imágenes de sistema y su estado de parcheo
avdroot status [target]	Detalles de un objetivo, incluido el dispositivo preinit
avdroot verify [target]	Comprobar que Magisk se ejecuta y que su devuelve uid=0
avdroot install	Instalar la app de Magisk en el emulador en ejecución
avdroot magisk info	Qué instalador se usaría y qué admite
avdroot magisk fetch	Descargar una versión (--list, --version, --prerelease)
avdroot trust-chrome	Hacer que Chrome acepte una CA de interceptación (--cert, --clear)
avdroot doctor	Explicar cómo se localizó cada ruta

Un objetivo es un nombre de AVD, una ruta de imagen de sistema o una ruta a un ramdisk.img. avdroot <command> --help muestra ejemplos para cada uno.

Flags globales

Estos se aplican a todos los comandos: