Anatomía de un APK

panorama · Actualizado el 15 de noviembre de 2026

1. Qué es un APK

Un APK (Android Package) es un fichero ZIP con una convención encima. No es un formato nuevo, ni un ZIP «modificado», ni lleva cifrado: cualquier unzip lo abre y lo que sale son ficheros normales colocados en rutas concretas. Lo propio de Android está en qué entradas tiene que haber y en qué formato va el contenido de cada una.

En el muestrario se cumple sin excepción: ninguna pieza lleva una entrada cifrada y un lector ZIP estricto abre todas.

Esta página presenta el vocabulario del resto de la documentación. Cada término se explica aquí en una frase; si quieres la definición completa, tienes el «glosario» al lado.

Para que una aplicación funcione hacen falta cuatro cosas, y no se comprueban a la vez: dos las mira el instalador y dos las necesita la app al arrancar.

Para Condición Dónde vive Qué pasa si falta
Instalar Un AndroidManifest.xml en la raíz, en formato binario «AXML» raíz del ZIP El instalador no sabe ni cómo se llama el paquete y rechaza el APK
Instalar Una firma válida con un esquema que la versión de Android acepte META-INF/ y/o el «APK Signing Block» El sistema rechaza el paquete antes de mirar nada más
Arrancar Código ejecutable en classes.dex (y classes2.dex, classes3.dex…), en formato «DEX» raíz del ZIP La aplicación instala pero no arranca, salvo que no tenga código
Arrancar Una tabla de recursos «resources.arsc», si se usa algún recurso raíz del ZIP Los identificadores del DEX no resuelven a nada

Los códigos de error del instalador, por si los buscas en un registro: si falta el manifiesto, INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION (−102), o INSTALL_PARSE_FAILED_NOT_APK (−100) si ni siquiera lo carga como APK. Si falta la firma, INSTALL_PARSE_FAILED_NO_CERTIFICATES (−103) y los de su familia.

Vocabulario mínimo.

  • Entrada: cada fichero que hay dentro del ZIP.
  • stored y deflate: los dos métodos de compresión que usa un APK. stored guarda la entrada sin comprimir; deflate la comprime.
  • Central Directory: el índice del ZIP, al final del fichero. Lista todas las entradas.
  • AXML: el XML binario de Android, el formato del manifiesto y de los .xml de res/.
  • DEX: el formato del código que ejecuta Android, en ficheros classes*.dex.
  • ABI: el tipo de procesador para el que se compiló el código nativo (arm64-v8a, armeabi-v7a, x86, x86_64).
  • split: una de las piezas en que Google Play reparte una app. Una app partida es un base.apk más varios split.
  • minSdk: la versión de Android más antigua en la que se puede instalar la app.
  • targetSdk: la versión de Android para la que la app dice estar preparada. Android activa o no ciertos comportamientos según ese número.
  • compileSdk: la versión del SDK de Android con la que se compiló.
  • AGP (Android Gradle Plugin): el complemento de Gradle que compila y empaqueta la app.

Las apps reales cumplen las cuatro casi siempre. Todas llevan manifiesto binario, alguna firma y resources.arsc, y el código falta en una sola: org.rayg.streaktracker (versión 12, de F-Droid), que declara hasCode="false" y se instala por sí sola.

Ojo: que falte la firma v1 no significa que falte la firma. Muchas apps ya no llevan ningún fichero .SF (casi dos de cada tres en Google Play, la mitad en IzzyOnDroid) y se instalan sin problema porque firman con los esquemas posteriores.

Las dos últimas condiciones de la tabla no las exige el instalador, y un APK puede no cumplirlas. Pasa con las piezas en que Google Play reparte una app (los splits, «sección 2.8 · Dónde encaja el AAB»). La que solo lleva el código nativo de un tipo de procesador (un config split de ABI) no trae classes.dex ni resources.arsc y declara hasCode="false". Aun así se instala junto a su base sin ningún problema («AAB, splits y contenedores → §4.2 · Los atributos del manifiesto», y «Formatos y extensiones → §4 · Cómo saber en diez segundos qué tienes delante»). En el muestrario no hay excepciones: todos los splits de configuración declaran hasCode="false" y no llevan DEX. Los de densidad y los de idioma, en cambio, sí traen casi siempre su propio resources.arsc. Ejemplos de la carpeta de adb de play/com.kidzoye.parentalcontrol:

  • Pieza split_config.arm64_v8a.apk, de ABI: un manifiesto de 1.192 bytes, 3 .so sin comprimir (40.952 bytes) y stamp-cert-sha256. No hay DEX ni resources.arsc.
  • Pieza split_config.xxhdpi.apk, de densidad: un resources.arsc de 11.476 bytes sin comprimir y 57 recursos (46 .png y 11 .webp).
  • Pieza base.apk, la base de la misma app: 1.339 entradas y un classes.dex sin comprimir de 6.531.232 bytes.

Quédate con dos palabras: binario y convención.

Binario, porque el manifiesto y los recursos no son texto. Si descomprimes un APK y abres AndroidManifest.xml con un editor de texto (cat AndroidManifest.xml), solo sale basura: el fichero está en un formato binario propio de Android (AXML). Sus primeros bytes, 03 00 08 00, marcan el comienzo de un bloque de tipo «XML binario» (en la jerga, un chunk RES_XML_TYPE); un XML de texto empezaría por <?xml. Todos los manifiestos del muestrario empiezan así. Lo mismo vale para los .xml bajo res/, aunque ahí solo hemos mirado el manifiesto. Pasar eso a texto legible es una reconstrucción, y es el nivel 2 de la «sección 4 · Los cuatro niveles de “decompilar”».

Convención, porque nada en el formato ZIP obliga a que exista classes.dex. Lo obliga el cargador de Android, y esa distinción importa mucho al analizar. El ZIP guarda cada fichero dos veces: en una cabecera justo delante de los datos y en el índice del final (el Central Directory). El formato no exige que las dos copias coincidan ni que los nombres sean únicos, aunque Android no lo tolere. Si dos programas leen copias distintas, ven ficheros distintos dentro del mismo APK. Eso explotaron las dos vulnerabilidades más conocidas de Android, Master Key y Janus: dos implementaciones que leyeron el mismo ZIP y no coincidieron. Están contadas en «Contenedor ZIP → §12 · Nota histórica: Master Key y Janus». En el muestrario no aparece ningún truco de este tipo: ni nombres repetidos en el Central Directory, ni cabeceras locales que contradigan el índice (nombre, tamaño, CRC o bit 3).

Lo que un APK no es, y conviene fijarlo pronto:

2. El ciclo de build

2.1 El diagrama

Tres cadenas independientes acaban en un ZIP, y sobre ese ZIP ya formado se dan dos pasos más. Si te equivocas en el orden de esos dos —alinear y después firmar—, el APK sale roto. Es el error más común.

CÓDIGO NATIVOCÓDIGO JVMRECURSOSR.javares/AndroidManifest.xmlaapt2 compile*.flataapt2 link-I android.jarAndroidManifest.xml (AXML)resources.arscres/** yacompilados.kt .javakotlinc / javac.classD8 o R8classes*.dex.c .cppCMake /ndk-buildlib/<abi>/*.somapping.txtempaquetadoZIPassets/META-INF/baseline.profzipalign -P 16 4apksigner signAPK final← v1, v2, v3,v3.1, v3.2 (+.idsig para v4)

apksigner puede poner hasta cinco esquemas de firma (v1, v2, v3, v3.1 y v3.2) y, aparte, un fichero .idsig para v4. En la práctica casi todo el mundo se queda en los tres primeros: lo más habitual es v1 + v2 + v3 (seis de cada diez apps de F-Droid) o solo v2 (casi la mitad en IzzyOnDroid). v3.1 y v3.2 son raros fuera de Google Play. Ojo: esto cuenta los esquemas presentes en el APK Signing Block o en META-INF/, no lo que apksigner verify da por verificado.

Fíjate en que, leído de derecha a izquierda, el diagrama es el mapa de la ingeniería inversa: cada flecha es una transformación, y la «sección 4 · Los cuatro niveles de “decompilar”» cuenta cuáles se pueden deshacer.

aapt2 (Android Asset Packaging Tool) es la herramienta oficial que convierte res/ y AndroidManifest.xml en los formatos binarios del dispositivo. Trabaja en dos fases separadas, y esa separación es toda la diferencia con el aapt original:

«AAPT2 supports faster compilation of resources by enabling incremental compilation. To accomplish incremental compilation, resource processing is separated into two steps: Compile: compiles resource files into binary formats. Link: merges all compiled files and packages them to a single package.»

aapt2 compile toma un fichero de recurso por invocación y produce un intermedio con extensión .flat. Lo de res/values/ sale como *.arsc.flat; todo lo demás, como *.flat; y los .png se pasan además por el crunch (una optimización que reduce el tamaño de la imagen) salvo que se le diga --no-crunch. Un .flat no es XML binario, aunque la documentación lo llame así. Es un contenedor propio de aapt2:

  • Empieza por la marca AAPT.
  • Guarda, en Protocol Buffers, la tabla de valores o una descripción del recurso.
  • Esa descripción va seguida de su contenido: el XML ya analizado, también en protobuf, o el fichero tal cual. En un .png, la imagen ya pasada por el crunch.

aapt2 link funde todos los .flat, resuelve las referencias contra android.jar (la opción -I) y emite tres cosas: la tabla resources.arsc, el AndroidManifest.xml ya en AXML, y —fuera del APK— el fichero R.java con las constantes que el compilador de Java va a necesitar. La documentación es explícita sobre lo que no produce: «the generated APK does not contain DEX bytecode and is unsigned. You can't deploy this APK to a device». Al final de esta rama hay un APK a medio hacer.

2.3 El código: javac/kotlinc, y luego D8 o R8

El compilador de Kotlin o de Java produce bytecode de la JVM en ficheros .class, uno por clase, big-endian y con una tabla de constantes propia por fichero. Android no ejecuta eso.

D8 convierte ese bytecode a DEX: un solo fichero con todas las clases y las tablas de cadenas, tipos, prototipos, campos y métodos compartidas. El porqué de ese cambio de reparto está en «Formato DEX → §1 · Qué es y por qué existe».

R8 es D8 más el trabajo que antes hacía ProGuard, en una sola pasada. La documentación oficial lo divide en tres operaciones: code shrinking (tree shaking) —partiendo de los puntos de entrada declarados en el manifiesto, construye el grafo de código alcanzable y borra el resto—, logical optimizations —inlining (copiar el cuerpo de un método en quien lo llama) y fusión de clases— y obfuscation (minification), que acorta los nombres de clases, campos y métodos: «com.example.MyActivity could become a.b.a».

De ahí sale «mapping.txt», el fichero con la correspondencia entre los nombres originales y los ofuscados. Sin él, la ofuscación es irreversible en la práctica; con él, es reversible de forma determinista — es lo que hace retrace. Ver «R8 y ProGuard».

Dos cambios que conviene tener presentes porque la documentación antigua circula mucho. Desde AGP 8.0, de abril de 2023, el modo full mode de R8 (el que aplica todas sus optimizaciones, no solo las compatibles con ProGuard) está activo por defecto. Y AGP 9.3 trae una DSL nueva (un lenguaje de configuración propio de Gradle): el bloque optimization { enable = true } con las reglas en el source set keepRules (la carpeta de ficheros de reglas del proyecto), que la «sección 4 de R8 y ProGuard · Cómo se enciende y dónde viven las reglas» pone al lado de la clásica.

¿Y qué versión usan las apps reales? Las de F-Droid van por delante: una de cada tres ya se compiló con AGP 9, mientras que en Google Play domina todavía AGP 8. Se sabe porque muchas apps llevan META-INF/com/android/build/gradle/app-metadata.properties, con la versión en el campo androidGradlePluginVersion. El cliente de F-Droid 2.0.2 (org.fdroid.fdroid), por ejemplo, se compiló con AGP 9.2.1.

2.4 El código nativo

Lo que se compila con el NDK no pasa por ninguna de las dos ramas anteriores: sale como bibliotecas compartidas ELF y se copia a lib/<abi>/ dentro del ZIP, un directorio por arquitectura. Es la única parte del APK que no es un formato propio de Android. Ver «Código nativo y ELF».

2.5 Empaquetado, alineación y firma

Los tres productos se meten en un ZIP junto con assets/, los perfiles de arranque y los metadatos de build, y sobre ese ZIP ya cerrado actúan dos herramientas más.

zipalign no reordena nada ni recomprime. Solo ajusta el relleno para que los datos de las entradas sin comprimir empiecen en un offset alineado. Así el sistema puede mapearlas con mmap(2), leyéndolas directamente desde el APK en vez de copiarlas a RAM. Hay dos alineaciones distintas y ambas necesarias: 4 bytes para toda entrada stored, y 16 KiB (16.384 bytes, -P 16) para los .so.

Los 4 bytes los cumple prácticamente todo el mundo: fallan apenas una docena de piezas en todo el muestrario. Los 16 KiB fallan más, sobre todo en el mercado chino, donde casi ninguna pieza con .so sin comprimir los respeta; en las demás fuentes falla una de cada veinte, más o menos. Dos ejemplos de piezas que fallan zipalign -c 4: com.qqgame.hlddz (versión 1571, mercado chino) y com.github.howeyc.crocgui (versión 48, F-Droid).

apksigner firma. Y aquí está la regla que hay que memorizar, en palabras de la documentación oficial:

«If you use apksigner, zipalign must be used before the APK file has been signed. If you sign your APK using apksigner and make further changes to the APK, its signature is invalidated.»

El motivo está en cómo se firma. Desde el esquema v2 la firma no va entrada a entrada: cubre el fichero por tramos:

  • el contenido de las entradas,
  • el Central Directory,
  • el EOCD (el registro que cierra el ZIP).

Del APK Signing Block en el que ella misma va guardada solo protege sus datos firmados. Mover un byte de esos tramos después de firmar la invalida. Ver «Alineación y zipalign» y la «sección 4 de Esquemas v1, v2 y v3 · v2: firma del fichero completo».

El APK Signing Block no guarda solo la firma. En los APK reales aparecen otros bloques con su propio identificador:

  • El sello de origen (source stamp), una marca de procedencia. Lo llevan casi todas las apps de Google Play y casi ninguna fuera.
  • El frosting, un bloque propio de Google Play. Mismo reparto: habitual en Play, rarísimo en el resto.
  • Los metadatos de dependencias de AGP, más frecuentes en IzzyOnDroid (tres de cada diez).
  • El canal de distribución de las tiendas chinas (los formatos Walle y VasDolly), que lleva casi un tercio de las apps chinas.

Por eso dos APK de la misma app pueden tener tamaños distintos aunque su código y sus recursos sean idénticos. Ejemplos con v2, v3, sello de origen, frosting y relleno: la pieza base.apk de play/com.kidzoye.parentalcontrol; su split split_config.arm64_v8a.apk lleva v2, v3, sello de origen y relleno, pero no frosting; y com.xingin.xhs (versión 9510803, mercado chino) lleva un canal de distribución en el bloque de firma. El detalle está en «APK Signing Block».

2.6 El ciclo entero, ejecutado

No necesitas Gradle ni Android Studio para nada de lo anterior: basta con las build-tools del SDK. Lo siguiente lo ejecutamos el 12 de agosto de 2026 con build-tools 37.0.0 (aapt2 2.20-15087165, D8 9.2.4-dev, apksigner 0.9), javac 21.0.10 y platforms/android-35, sobre un proyecto mínimo de una Activity y un string.

BT=~/Library/Android/sdk/build-tools/37.0.0
AJ=~/Library/Android/sdk/platforms/android-35/android.jar

# 1-2 · recursos: compilar y enlazar (produce AXML + resources.arsc + R.java)
$BT/aapt2 compile --dir src/res -o out/res.zip
$BT/aapt2 link -o out/base.apk -I $AJ --manifest src/AndroidManifest.xml \
    --java out/gen --min-sdk-version 24 --target-sdk-version 35 out/res.zip

# 3-4 · código: javac produce bytecode de la JVM, D8 lo convierte a DEX
javac --release 17 -cp $AJ -d out/classes src/java/MainActivity.java \
    out/gen/com/ejemplo/demo/R.java
$BT/d8 --release --min-api 24 --lib $AJ --output out/ out/classes/com/ejemplo/demo/*.class

# 5 · empaquetar: el DEX entra en el APK que dejó aapt2
cp out/base.apk out/app-unaligned.apk
(cd out && zip -q -X app-unaligned.apk classes.dex)

# 6 · alinear · 7 · firmar
$BT/zipalign -P 16 -f -v 4 out/app-unaligned.apk out/app-aligned.apk
keytool -genkeypair -keystore out/demo.jks -storepass pruebas123 -keypass pruebas123 \
    -alias demo -keyalg RSA -keysize 2048 -validity 30 -dname "CN=Ejemplo Demo, C=ES"
cp out/app-aligned.apk out/app-release.apk
$BT/apksigner sign --ks out/demo.jks --ks-pass pass:pruebas123 \
    --key-pass pass:pruebas123 --ks-key-alias demo out/app-release.apk

# 8 · verificar
$BT/apksigner verify -v --v4-signature-file out/app-release.apk.idsig out/app-release.apk

De aapt2 compile sale un solo intermedio, values_strings.arsc.flat; de aapt2 link, un APK con dos entradas (AndroidManifest.xml de 1.224 bytes y resources.arsc de 564) más el R.java, donde ya se ve la estructura 0xPPTTEEEE del resource ID — paquete 7f, tipo 01, entrada 0000:

public final class R {
  public static final class string { public static final int app_name=0x7f010000; }
}

dexdump -f sobre el classes.dex recién producido responde DEX version '037'. No es arbitrario: la versión la elige D8 a partir de --min-api 24, y la correspondencia completa está medida en «Formato DEX → §4 · magic y la tabla de versiones». Las apps reales siguen la misma regla: con minSdk 24 o 25, casi todas llevan el DEX en versión 037, como el cliente de F-Droid 2.0.2. Y la verificación final:

Verifies
Verified using v1 scheme (JAR signing): false
Verified using v2 scheme (APK Signature Scheme v2): true
Verified using v3 scheme (APK Signature Scheme v3): true
Verified using v3.1 scheme (APK Signature Scheme v3.1): false
Verified using v3.2 scheme (APK Signature Scheme v3.2): false
Verified using v4 scheme (APK Signature Scheme v4): true

Tres cosas de esa salida que suelen aprenderse tarde:

  1. apksigner generó un .idsig sin pedírselo. La firma v4 vive en un fichero acompañante, fuera del APK, y apksigner verify no la mira salvo que le pases --v4-signature-file.
  2. v1: false no significa que no haya firma v1. El APK resultante contiene META-INF/MANIFEST.MF, META-INF/DEMO.SF y META-INF/DEMO.RSA. Lo que dice apksigner es que, con minSdkVersion 24, la verificación no necesita v1: si repites la orden con --min-sdk-version 21, responde v1: true. Pasa igual con un APK del muestrario: el cliente de F-Droid 2.0.2, con minSdk 24, trae META-INF/CIARANG.SF y CIARANG.RSA, y apksigner verify -v responde v1: false, v2: true, v3: true, v3.1: false, v3.2: false y v4: false.
  3. El APK alineado pesa 2.293 bytes y el firmado 8.587. La firma no es un adorno.

El resultado tiene seis entradas —AndroidManifest.xml, resources.arsc, classes.dex y los tres de META-INF/— y es exactamente la anatomía mínima de la «sección 1 · Qué es un APK».

2.7 Los nombres de las tareas de Gradle

En un proyecto real nada de lo anterior se invoca a mano: lo orquesta el Android Gradle Plugin. Cuando se escribió esta sección (12 de agosto de 2026), su versión estable era la 9.3.1, aunque en el muestrario, descargado en octubre, ya abunda la 9.4.1. Los nombres de tarea documentados son tres, y los tres llevan el nombre de la variante en camel case:

Tarea Produce
assemble<Variante> — assembleDebug, assembleRelease Un APK en <módulo>/build/outputs/apk/
install<Variante> — installDebug Lo mismo, y lo instala en el dispositivo conectado
bundle<Variante> — bundleRelease, :base:bundleDebug Un AAB

Cada una dispara por debajo una cadena de tareas internas: compilación de Kotlin, fusión de recursos, R8, empaquetado. Sus nombres no forman parte del contrato público y han cambiado varias veces entre versiones de AGP, así que aquí no los citamos. Si los necesitas, ./gradlew tasks los lista para tu versión; es la única respuesta que no envejece.

La compilación de depuración se firma sola con una clave de depuración y sale ya alineada. La de release exige una clave propia. Las de depuración casi no llegan al público: en todo el muestrario hay apenas una decena de apps con el certificado de depuración (CN=Android Debug) o con android:debuggable="true", y ninguna declara testOnly. Ejemplos: be.bhasher.mobileinpact (F-Droid), firmada con el certificado de depuración, y com.particlesdevs.photoncamera (IzzyOnDroid), con debuggable="true".

2.8 Dónde encaja el AAB

Desde mayo de 2018 —se presentó en el Google I/O— existe el Android App Bundle, y desde agosto de 2021 es obligatorio para las aplicaciones nuevas de Google Play. Cambia quién genera el fichero instalable:

«An Android App Bundle is a publishing format that includes all your app's compiled code and resources, and defers APK generation and signing to Google Play.»

El desarrollador sube un .aab. Play lo procesa y genera del lado del servidor el conjunto de APK que cada dispositivo concreto necesita: un base.apk más los split (piezas) de su procesador (ABI), su densidad de pantalla y sus idiomas. El resto ni se descarga. No todas las apps llevan los tres tipos: el de procesador es casi universal, y el de idioma falta en bastantes. También hay piezas de módulos (feature) y de datos grandes (asset pack), sobre todo en juegos («sección 2.9 · Una app de Play tal como queda en el móvil»). Dos ejemplos. La carpeta de adb de play/com.kidzoye.parentalcontrol solo tiene dos splits, de procesador y de densidad, y ninguno de idioma. El .apkm de Google Keep (5.26.411.03) trae un procesador (armeabi_v7a), una densidad (xhdpi) y 24 idiomas; es la variante para Wear OS, así que no es la combinación típica.

dispositivoGoogle Playdesarrollador.aabsplitsbundleReleaseapp.aab(protobuf)generación desplits + firmacon la clave dePlay AppSigningbase.apk+ config.arm64+ config.xxhdpi+ config.es

Dos consecuencias que atraviesan todo el «muestrario»:

  • La firma que ve el usuario no tiene por qué ser la del desarrollador. Con Play App Signing, la clave que firma lo que reciben los usuarios la guarda Google, y la que guarda el desarrollador es la de upload. Pero el certificado no tiene por qué cambiar, porque el desarrollador puede subir su propia clave a Play. Los seis paquetes del muestrario que están a la vez en Google Play y en la web de su autor (WhatsApp, Viber, Firefox, Brave, LarkPlayer y KanaQuiz) llevan el mismo certificado en los dos sitios. Lo que sí cambia la firma es recompilar la app en otra tienda: de los cuatro paquetes que están en Google Play y también en F-Droid o IzzyOnDroid, ninguno coincide. El certificado genérico que crea Play (CN=Android, OU=Android, O=Google Inc.) es frecuente en Play, sobre todo fuera de las apps más instaladas, y prácticamente no aparece en ningún otro sitio. Tres de los seis pares:

    • WhatsApp: el APK de la web del autor (WhatsApp.apk) y la pieza base.apk del .apkm de Google Play (2.26.42.9).
    • Firefox: el APK arm64-v8a de la web de Mozilla (158.0.1) y el APK de Google Play que sirve APKPure (158.0.2).
    • KanaQuiz: kanaquiz-v0.15.1-release.apk de la web del autor y la pieza base.apk de Google Play.

    El mismo paquete puede venir de varias fuentes, y no siempre con la misma firma. Entre F-Droid e IzzyOnDroid, cuando los ficheros difieren, el certificado no coincide en siete de cada diez casos. Lo normal es que F-Droid firme con su propia clave (lo hace en seis de cada diez de sus apps) y que en IzzyOnDroid firme el autor. Droid-ify 0.7.8, por ejemplo, lleva CN=FDroid en un sitio y CN=Mohit Sharma en el otro. Como Android no deja actualizar una app con otro certificado, en esos casos cambiar de tienda obligaría a desinstalar la app. Es la regla de la plataforma; no lo hemos probado instalando nada.

  • Una aplicación instalada ya no es un fichero. Para analizarla hay que recoger todos sus splits del dispositivo o fusionarlos en un APK único. Lo segundo no es trivial: hay que unir tablas de recursos, sanear el manifiesto y renumerar los DEX. Ver «Fusión de splits».

Puedes reproducir esa generación en local con bundletool, la misma herramienta que usan Android Studio, AGP y el propio Play. El muestrario no trae ningún .aab, pero sí el resultado: la mayoría de las apps de Play llegan partidas en piezas. Así se ve por dentro el .apkm de Google Keep:

unzip -l 'play/com.google.android.keep_5.26.411.03.97-220679628_1arch_1dpi_24lang_…_apkmirror.com.apkm' | head -12
     2193  10-19-2026 13:46   META-INF/MANIFEST.MF
     2314  10-19-2026 13:46   META-INF/APKMIRRO.SF
     1597  10-19-2026 13:46   META-INF/APKMIRRO.RSA
     1107  10-19-2026 13:46   info.json
    69944  10-19-2026 13:42   icon.png
 17645511  10-19-2026 13:45   base.apk
    78034  10-19-2026 13:45   split_config.ar.apk
   102813  10-19-2026 13:45   split_config.armeabi_v7a.apk
    73938  10-19-2026 13:45   split_config.de.apk
   159954  10-19-2026 13:45   split_config.en.apk

Son 33 entradas y 19.975.507 bytes sin comprimir. El .apkm es un ZIP que lleva su propia firma (APKMIRRO), un info.json, un icono y los APK. Este es el de la variante Wear OS de Keep: un solo procesador y una sola densidad. Las fechas son las de la descarga (19 de octubre de 2026), no la de 1981 de la «sección 3.1 · Lo primero: es un ZIP».

toc.pb es un índice (table of contents) en Protocol Buffers que dice a qué teléfono va cada pieza. Solo bundletool lo escribe, así que su presencia distingue un APK Set genuino (.apks) de un ZIP de piezas con la extensión puesta a mano. En el muestrario no hay ningún .apks, y ningún .apkm ni .xapk lleva toc.pb. Las extensiones, eso sí, no engañan: cada contenedor tiene la estructura que le toca, y ningún .apk suelto es un contenedor camuflado. El más grande es un .xapk de APKPure, Call of Duty: Mobile 1.0.57, con 2,35 GB. El detalle completo, en «AAB, splits y contenedores → §6 · Detección por estructura, nunca por extensión».

Dentro del .apkm hay piezas que se pueden abrir una a una. Por ejemplo, del mismo .apkm de Keep:

  • Pieza base.apk, 17.645.511 bytes.
  • Pieza split_config.armeabi_v7a.apk, de procesador, 102.813 bytes: un manifiesto, 3 .so comprimidas y stamp-cert-sha256.
  • Pieza split_config.xhdpi.apk, de densidad, 64.162 bytes: 47 entradas, res/ y stamp-cert-sha256.

2.9 Una app de Play tal como queda en el móvil

Una aplicación instalada desde Google Play no es un fichero: es una carpeta. Así se ve la de play/com.kidzoye.parentalcontrol, sacada con adb shell pm path y adb pull:

base.apk                      8.484.479
split_config.arm64_v8a.apk       82.333
split_config.xxhdpi.apk         108.287

base.apk lleva el código (classes.dex), el manifiesto y los recursos comunes. El split de procesador trae solo las bibliotecas nativas de arm64-v8a, sin código ni resources.arsc. El de densidad trae las imágenes para pantallas xxhdpi y su propio resources.arsc. Esta app no trae split de idioma, y eso es poco común: solo una carpeta de cada veinte tiene esa forma.

Lo típico es una carpeta de cuatro piezas: la base más una de procesador, una de densidad y una de idioma. Es la combinación más frecuente, y la mitad de las carpetas lleva los tres tipos a la vez. Los splits se llaman siempre split_config.<tipo>.apk. Las piezas de esa app:

  • base.apk: 1.339 entradas, classes.dex sin comprimir de 6.531.232 bytes y resources.arsc de 570.040 bytes.
  • split_config.arm64_v8a.apk: manifiesto, 3 .so (40.952 bytes) y stamp-cert-sha256.
  • split_config.xxhdpi.apk: resources.arsc de 11.476 bytes y 57 imágenes.

Fuera de Google Play, lo habitual es recibir esa carpeta ya empaquetada en un solo fichero. Un .apkm (APKMirror) lleva info.json (versión, idiomas, procesadores y densidades), un icono, un APKM_installer.url (un enlace que no se abre ni se sigue), la firma META-INF/APKMIRRO.* del propio ZIP y los APK. Un .xapk (APKPure) lleva un manifest.json, a veces un icono, y los APK, y no lleva firma propia. Los del muestrario siguen esa forma sin excepción, y ninguno usa Zip64, ni siquiera el .apkm más grande (com.olzhas.carparking.multyplayer 4.9.11, 2,28 GB).

Además de las piezas de procesador, densidad e idioma, una app puede traer módulos (feature splits, funciones que se instalan aparte) y paquetes de datos (asset packs, sobre todo en juegos). Los módulos pueden llevar código; los paquetes de datos, no. Antes de los paquetes de datos se usaba un fichero .obb con los datos del juego, y todavía quedan un par de .apkm que lo traen. En el muestrario:

Módulos (feature) Paquetes de datos (asset pack)
Apps más instaladas de Play con splits (454) 43 (9 %), 186 piezas 51 (11 %), 82 piezas
Apps del sorteo de Play con splits (319) 4 (1 %) 18 (6 %), 20 piezas

Unos dos tercios de los módulos llevan DEX; ningún paquete de datos lo lleva, ni tampoco resources.arsc. Los paquetes de datos son grandes: de mediana, decenas o cientos de MB. Y dos módulos nunca comparten el mismo id de paquete. Cuatro ejemplos:

  • Módulo: la pieza split_df_pipo_external_payments.apk del .apkm de TikTok (com.zhiliaoapp.musically 47.4.16), con el paquete 0x56.
  • Paquete de datos: la pieza split_install_time_asset_pack.apk de com.xd.muffin.gp.global, de 3,75 GB y 17.463 entradas, el mayor del muestrario.
  • Paquete de datos: la pieza split_UnityStreamingAssetsPack.apk del .apkm de com.igg.android.lordsmobile 2.206, de 2,12 GB.
  • Un .obb: el .apkm de com.zakg.scaryteacher.hellgame 10.5 trae un APK y un .obb, de 1.102.147.339 bytes en total.

Ni siquiera los 3,75 GB necesitan Zip64: ninguna pieza del muestrario lo usa. La mayor, de 4,08 GB, es com.tencent.tmgp.yongyong.mrzh (versión 744, mercado chino; 4.076.962.064 bytes), y queda por debajo de 4 GiB.

3. Inventario comentado de un APK real

Todo lo de esta sección lo hemos medido sobre el cliente de F-Droid 2.0.2 del muestrario (org.fdroid.fdroid, versionCode 2000052; minSdk 24, targetSdk 37 y compileSdk 37; 12.569.951 bytes; compilado con AGP 9.2.1). Las medidas se hicieron entre el 19 y el 27 de octubre de 2026. Para repetirlas a mano te bastan las órdenes unzip y xxd de abajo.

3.1 Lo primero: es un ZIP

MUESTRARIO=<carpeta del muestrario>
unzip -l $MUESTRARIO/fdroid/org.fdroid.fdroid_2000052.apk | tail -3
   102495  01-01-1981 01:01   META-INF/MANIFEST.MF
---------                     -------
 25588494                     973 files

Novecientas setenta y tres entradas. La última de la lista ya no es resources.arsc sino un fichero de la firma v1, porque apksigner añade META-INF/MANIFEST.MF, .SF y .RSA al final.

Y esa fecha, 01-01-1981 01:01, no es la de compilación. Es una fecha fija que ponen varias herramientas de empaquetado para que el resultado sea idéntico cada vez que se construye (en el Central Directory sale 01:01:02, porque el ZIP guarda los segundos de dos en dos). Es lo habitual: la llevan en todas sus entradas casi todas las piezas de F-Droid, IzzyOnDroid y Google Play. En el mercado chino, en cambio, casi no aparece.

Ojo, porque no prueba que el APK lo haya hecho AGP. También la escriben bundletool y otras herramientas que rehacen el ZIP: el split split_config.arm64_v8a.apk de play/com.kidzoye.parentalcontrol lleva todo a 1981 sin que lo haya escrito AGP.

3.2 Las categorías

Agrupando las 973 entradas por su prefijo de ruta, con el tamaño sin comprimir y el método de compresión de cada grupo:

categoria                                  nº bytes sin compr.   metodo
1  AndroidManifest.xml                      1          29.980   1 deflate
2  classes*.dex                             3      20.586.860   3 deflate
3  resources.arsc                           1       2.087.752   1 stored
4  res/                                   703         915.791   522 deflate · 181 stored
5  lib/<abi>/                               4          37.392   4 stored
6  assets/dexopt/ (baseline profile)        2          11.722   2 stored
7  assets/                                 94         156.848   91 deflate · 3 stored
8  META-INF/ firma v1                       3         206.467   3 deflate
9  META-INF/ resto                        144          90.749   144 deflate
10 raiz y otros                            18       1.464.933   18 deflate

Lo que salta a la vista: el código (classes*.dex) es el 80 % de los bytes, y la firma v1 pesa más que todo assets/. Las categorías son estas: la 8 son MANIFEST.MF y los .SF, .RSA, .DSA y .EC de META-INF/; la 9, el resto de META-INF/; la 6, assets/dexopt/; la 7, el resto de assets/; y la 10, todo lo que no empieza por un prefijo anterior (las carpetas kotlin/ y org/, DebugProbesKt.bin y version.properties). La tabla sale de unzip -l agrupando por prefijo.

3.3 Categoría por categoría

1 · AndroidManifest.xml — Una sola entrada, en la raíz, en formato AXML. Sus primeros bytes lo confirman:

unzip -p $MUESTRARIO/fdroid/org.fdroid.fdroid_2000052.apk AndroidManifest.xml | xxd -l 16
00000000: 0300 0800 1c75 0000 0100 1c00 6c32 0000  .....u......l2..

03 00 es RES_XML_TYPE, 08 00 el tamaño de la cabecera del bloque y 1c 75 00 00 el tamaño total del fichero. Android guarda los números con el byte menos significativo primero (little-endian): 1c 75 00 00 se lee 0x0000751C, es decir, 29.980 bytes, el tamaño del manifiesto en la tabla de la «sección 3.2 · Las categorías». Después empieza la tabla de cadenas (string pool: tipo 0x0001, cabecera 0x1C, tamaño 0x326C, 12.908 bytes). Es la misma estructura de bloques (chunks) que usa resources.arsc. Ver «XML binario (AXML) → §2 · El sustrato de chunks».

2 · classes*.dex — Aquí, tres ficheros: 9.297.608, 9.622.160 y 1.667.092 bytes (20.586.860 en total), en versión 037. Un fichero DEX puede nombrar como mucho 65.536 métodos distintos, contando los de Android y los de las bibliotecas que la app llama. Las apps grandes pasan de ese límite y reparten su código en classes.dex, classes2.dex, classes3.dex…, numerados sin saltos. Los dos primeros de F-Droid 2.0.2 están casi llenos: 65.003 y 65.224 métodos (el tercero tiene 9.668). Tener varios DEX es cosa de apps grandes: lo normal en Google Play (seis de mediana en las más instaladas), minoritario en F-Droid e IzzyOnDroid (una de cada tres). Ninguno pasa del límite y ninguna app tiene la numeración con huecos. El orden es semántico: si una clase se define en dos ficheros, gana la del primero en orden de carga. Ver «Formato DEX», secciones «1» y «15», y el juego de instrucciones en «Bytecode Dalvik».

3 · resources.arsc — La tabla que convierte cada resource ID de 32 bits en el valor que corresponde a la configuración del dispositivo. Está stored, sin comprimir (aquí, 2.087.752 bytes): desde targetSdkVersion 30 es obligatorio, porque el sistema la lee directamente de la memoria. Las apps lo cumplen: con ese targetSdk o más, ninguna lo lleva comprimido. Solo hay una que falla, y por poco: dudeofx.eval (versión 102, targetSdk 36) lo guarda sin comprimir pero desalineado, con los datos en una posición que no es múltiplo de 4. Por debajo de 30 sí aparece alguno comprimido. Ver «Tabla de recursos».

4 · res/ — Los 703 ficheros de recurso ya compilados. Los .xml de aquí no son texto: son AXML, igual que el manifiesto. El reparto de compresión no es caprichoso: los 522 .xml van deflate y los 181 stored son 180 imágenes .png y un sonido .ogg, formatos que ya vienen comprimidos y a los que deflate no les quitaría nada. El nombre del fichero ya no se conserva: AGP acorta las rutas por defecto (res/-1.xml, res/0M.xml, res/15.png), sin ofuscar nada. Aquí lo hace en 506 de las 703 entradas, y lo mismo pasa en la gran mayoría de las apps de F-Droid e IzzyOnDroid. Ofuscar de verdad es otra cosa, y es raro. AndResGuard, una herramienta que renombra los recursos, crea una carpeta r/; aparece sobre todo en apps chinas (14 de 100). aapt2 optimize --collapse-resource-names reduce los nombres de resources.arsc a uno genérico, y apenas lo usa nadie. Una ruta «plana» es res/<nombre corto>.<ext>, sin la carpeta de tipo (res/-4.png, res/0M.xml).

5 · lib/<abi>/ — Aquí van las bibliotecas nativas, una carpeta por tipo de procesador (ABI). El cliente de F-Droid 2.0.2 tiene cuatro .so, una por ABI, todas libandroidx.graphics.path.so y sin comprimir (arm64-v8a 10.096 bytes, armeabi-v7a 7.252, x86 9.284 y x86_64 10.760; 37.392 en total). Eso de «todas la misma» es cierto aquí, no es una regla. Cuatro carpetas significan cuatro ABIs empaquetadas, no necesariamente cuatro soportadas de verdad. En Play, más de una de cada cuatro apps con varias ABIs tiene carpetas con bibliotecas distintas; 8 Ball Pool 56.33.0 (com.miniclip.eightballpool, del .xapk de APKPure) es un ejemplo. Así que lee las .so de cada carpeta en vez de contar carpetas.

Las .so pueden ir sin comprimir y alineadas (extractNativeLibs="false") o comprimidas, y entonces Android las extrae al instalar. En F-Droid y en Play predomina lo primero; en el mercado chino, lo segundo (81 de 100). Ver «Código nativo y ELF → §2 · lib/<abi>/ y las ABIs vigentes».

6 · assets/dexopt/ — baseline.prof y baseline.profm: la lista de métodos que conviene compilar por adelantado para que la aplicación arranque rápido la primera vez. Aquí, baseline.prof de 10.256 bytes y baseline.profm de 1.466, sin comprimir. Van casi siempre en pareja, y son muy comunes: los llevan la mayoría de las apps fuera del mercado chino. Ninguna app lleva solo el .profm, y los splits de Play no llevan ninguno de los dos. Ver «Artefactos auxiliares → §3 · Baseline profiles».

7 · assets/ — Ficheros que se entregan tal cual, sin identificador de recurso. Se abren por ruta con AssetManager. Es un sistema de ficheros opaco dentro del APK, sin índice y sin restricciones de nombre. Ahí van los modelos de aprendizaje automático, las bases de datos, los recursos de los motores de juegos y a veces código. El payload cifrado de un packer es solo uno de los casos, y no el más frecuente. En las apps más instaladas de Play, casi cuatro de cada diez llevan un .dex, .jar o .apk dentro de assets/, pero la mayoría es assets/audience_network.dex, el SDK de anuncios de Meta, no un protector. En F-Droid e IzzyOnDroid es rarísimo. Mira siempre assets/ además de los classesN.dex.

8 · META-INF/ firma v1 — La firma v1 son tres ficheros: MANIFEST.MF (102.495 bytes), con una huella criptográfica (digest) de cada fichero del APK; CIARANG.SF (102.622 bytes), con las huellas de las secciones del anterior; y CIARANG.RSA (1.350 bytes), que guarda la firma y el certificado en formato PKCS#7. El nombre base sale del alias de la clave pasado a mayúsculas y cortado a ocho caracteres. Nadie lo comprueba. A veces delata a quien firmó: APKMIRRO es APKMirror, que firma sus contenedores «.apkm» (todos los .apkm y ningún .xapk; por ejemplo, el .apkm de Keep de la «sección 2.8 · Dónde encaja el AAB» lleva META-INF/APKMIRRO.SF y .RSA), y BNDLTOOL marca los splits de Google Play (por ejemplo, split_config.arm64_v8a.apk de play/com.kidzoye.parentalcontrol). Pero el nombre no es una huella segura: cada tienda tiene sus costumbres (ocho cifras hexadecimales en F-Droid, CERT en IzzyOnDroid) y cualquiera puede elegir el alias que quiera. F-Droid 2.0.2 sigue con v1, aunque su minSdk 24 la hace innecesaria. Ver «Esquemas v1, v2 y v3».

9 · META-INF/ resto — Metadatos que vienen de las dependencias y del compilador: services/ del mecanismo ServiceLoader, un *.version por cada biblioteca AndroidX, app-metadata.properties con la versión del plugin de compilación (AGP) y version-control-info.textproto con el commit de git del que salió el APK. El primero lo lleva la gran mayoría de las apps. El segundo es menos útil de lo que parece: aunque esté, muchas veces no trae commit sino NO_SUPPORTED_VCS_FOUND o NO_VALID_GIT_FOUND, así que no es una forma fiable de saber de qué commit sale una app. F-Droid 2.0.2 trae app-metadata.properties con androidGradlePluginVersion=9.2.1 y el commit 08f444713cefc97a8fa3cd3161a4484db6db54c8.

10 · Raíz y otros — Y aquí está lo interesante, lo que no encaja en ninguna convención. Son 18 entradas (8 de kotlin/, 8 de org/ y 2 sueltas):

DebugProbesKt.bin                 kotlin/kotlin.kotlin_builtins
version.properties                kotlin/collections/collections.kotlin_builtins
org/bouncycastle/pkix/CertPathReviewerMessages.properties
org/bouncycastle/x509/CertPathReviewerMessages.properties

(La lista completa tiene, además, otros seis kotlin_builtins, las versiones en alemán de los mensajes de BouncyCastle, tres ficheros de datos de org/bouncycastle/pqc/ y un caso de prueba de org/apache/commons/net/.)

Leído sin abrir un solo DEX: la app es Kotlin (los kotlin_builtins), usa corrutinas (DebugProbesKt.bin) y lleva BouncyCastle para criptografía. Esta vez no hay huella de OkHttp: falta okhttp3/internal/publicsuffix/publicsuffixes.gz. Ese inventario es la huella del stack, y sale gratis. No es infalible, eso sí: a veces R8 o la configuración de empaquetado quitan el fichero, y hay apps con clases Kotlin en el DEX y sin kotlin_builtins (pocas fuera del mercado chino, casi una de cada cinco dentro). Las huellas de Kotlin son las más comunes, en más de ocho de cada diez apps; la de OkHttp abunda en Play y en el mercado chino y escasea en F-Droid.

3.4 Lo que cambia en un APK más moderno

El mismo recuento sobre Lumo (me.proton.android.lumo, versión 50; Lumo 1.2.18, 93.269.595 bytes, minSdk 29, targetSdk 36) da dos diferencias con el cliente de F-Droid que no son cosméticas. La tabla compara los dos; la tercera fila muestra algo que ya no cambia:

F-Droid 2.0.2 (minSdk 24) Lumo 1.2 (minSdk 29)
classes*.dex deflate stored (2 DEX: 1.506.160 bytes con 1.840 clases y 1.888.156 con 2.096)
lib/<abi>/ 4 entradas, stored y alineadas a 16 KiB 16 entradas, stored y alineadas a 16 KiB (cuatro ABIs)
Firma v1 Presente (3 entradas en META-INF/) Ausente: ningún .SF, solo v2

La alineación a 16 KiB ya no es una diferencia: las dos apps la cumplen. Lo que decide cada cosa es esto:

  1. La firma v1 sobra si minSdk es 24 o más (Android 7.0), porque desde ahí todo dispositivo entiende v2 («Esquemas v1, v2 y v3 → §9 · Por qué un APK moderno lleva v1+v2+v3 (y cuándo se puede omitir v1)»). Sobrar no quiere decir que falte: con minSdk 24 o más, más de la mitad de las apps de F-Droid la siguen llevando, aunque en Play ya es minoritaria. Con minSdk menor de 24 la llevan todas, sin excepción.
  2. Los DEX sin comprimir los hace AGP por defecto desde la versión 4.2 si minSdk es 28 o más («Contenedor ZIP → §9 · Métodos de compresión»). Con ese minSdk lo cumplen más de nueve de cada diez apps. Por debajo de 28 casi nunca pasa en F-Droid, pero sí en más de la mitad de las de Play.
  3. apksigner verify solo comprueba lo que necesita para ese minSdk. En Lumo responde v1: false y v2: true, y nada más. En dev.kaleve.nonius (versión 6, minSdk 36) responde v1: false, v2: false y v3: true. El cliente de F-Droid 2.0.2 (minSdk 24) lleva v1 sin necesitarla y apksigner responde v1: false, v2: true y v3: true. Que apksigner verifique o no una pieza depende además de la versión de Java y del minSdk declarado, como dice el recuadro de la «sección 1 · Qué es un APK».

El targetSdk decide otra cosa que aquí no se ve porque los dos lo cumplen: desde 30, resources.arsc tiene que ir sin comprimir, y en los dos va stored.

minSdk y targetSdk en el muestrario. La app típica se instala desde Android 7 (minSdk 24 de mediana) y apunta a una versión reciente (targetSdk 35 o 36). Google Play va más al día: solo una de cada diez apunta por debajo de 35, frente a cuatro de cada diez en F-Droid. Las chinas son la excepción, con targetSdk 30 de mediana. El cliente de F-Droid 2.0.2 tiene minSdk 24, targetSdk 37 y compileSdk 37; Lumo, minSdk 29 y targetSdk 36.

La alineación a 16 KiB. Algunos móviles nuevos manejan la memoria en páginas de 16 KiB en vez de 4 KiB. Una biblioteca nativa solo funciona ahí si sus segmentos están alineados a 16 KiB y, si va sin comprimir, empieza en un múltiplo de 16.384 dentro del ZIP. Google Play lo exige a las aplicaciones con targetSdk 35 o superior en dispositivos de 64 bits, y las páginas oficiales dan dos fechas: el 1 de noviembre de 2025, que anunció el blog de Android Developers para las aplicaciones nuevas y las actualizaciones, y el 1 de febrero de 2027, que da hoy la guía para las actualizaciones. Las dos fuentes, y lo que ninguna aclara, están en la «sección 6.2 de Código nativo y ELF · Fecha y alcance en Google Play».

El targetSdk es lo que más pesa. Con 35 o más, más del 92 % de las apps con código nativo de arm64-v8a cumple en F-Droid, IzzyOnDroid y Play; por debajo de 35, menos de la mitad. En el mercado chino casi ninguna cumple (7 de 98). Las cifras dependen de la definición, y aquí usamos dos. La guía de Android pide todos los segmentos PT_LOAD de las .so de arm64-v8a alineados a 16 KiB, y las .so sin comprimir empezando en múltiplo de 16.384 en el ZIP; así cumplen en torno al 85 % de las apps fuera del mercado chino. La del cargador de Android 17 (que no entra en modo de compatibilidad y tiene el ZIP bien) es más estricta y deja unos puntos menos, entre el 74 % y el 80 %. El cliente de F-Droid 2.0.2 es compatible (un ELF de arm64-v8a con p_align 16384, sin comprimir y alineado), y Lumo lleva 16 .so sin comprimir a 16 KiB. En estas cuentas, las apps «sin veredicto» (1 de F-Droid y 2 de Play) no cuentan como compatibles. Son ejemplos:

  • Las piezas split_config.arm64_v8a.apk de los .apkm de com.heytap.music 48.15.1.60.0 y de com.oppo.music 58.15.1.58.5, sin veredicto: su lib/arm64-v8a/libjni_signal.so (52.517 bytes) está roto por una conversión a texto (2.990 caracteres U+FFFD), aunque la pieza verifica con apksigner.
  • xyz.jekyllex (versión 82, F-Droid), sin veredicto: tiene más de 2.000 ELF y no los analizamos más.

3.5 Lo normal: el inventario sobre muchos APK

El APK de la «sección 3 · Inventario comentado de un APK real» es uno solo, y para saber qué es normal hay que mirar cientos. Una app típica de F-Droid tiene unas 660 entradas y 12 MB sin comprimir, y la mitad de esos bytes es código. Una de Google Play (de las más instaladas) tiene unas 3.200 entradas y 103 MB, con 6 DEX. Una de las chinas tiene unas 8.900 entradas y 360 MB, y el peso se desplaza a las bibliotecas nativas (39 %). El cliente de F-Droid 2.0.2 (973 entradas, 25,6 MB) está por encima de la mediana de F-Droid en las dos medidas. Para Play se mide la pieza base, sin contar los splits.

Grupo Entradas Tamaño Código (DEX) Bibliotecas DEX por app
F-Droid 660 12,0 MB 52 % 0,4 % 1
IzzyOnDroid 763 11,7 MB 53 % 0,4 % 1
Google Play, las más instaladas 3.186 102,7 MB 50,5 % 0 6
Google Play, sorteo 1.033 43,0 MB 51 % 0 3
Mercado chino 8.937 360,2 MB 24 % 39 % 3

Todas son medianas por app. Las columnas de porcentaje son la mediana de la parte de los bytes sin comprimir de cada app, y por eso no suman 100. Según cómo se cuenten las entradas, la mediana cambia un poco (lo verás en la «sección 2.1 de El contenedor ZIP · Cómo es un APK típico»). La pieza con más entradas es com.ss.android.ugc.aweme (versión 400801, mercado chino), con 47.103.

3.6 El mismo formato en otras tiendas

Un APK real depende de la tienda. Las 100 apps chinas del muestrario (60 de la tienda de 360 y 40 descargadas a mano de Tencent) se parecen poco a las de F-Droid o Google Play. Apuntan a un Android más antiguo (targetSdk 30 de mediana), traen casi siempre solo código de 64 bits y conservan la firma v1 incluso cuando les sobra. Pesan mucho más, con casi el 40 % de los bytes en bibliotecas nativas. Y usan cosas que en otras tiendas casi no se ven: el canal de distribución en el bloque de firma (casi un tercio), protectores (38 de 100, «sección 5 · Qué sobrevive siempre a la ofuscación») y binarios nativos fuera de lib/ (79 de 100). Ejemplos: com.ss.android.ugc.aweme (400801), la pieza con más entradas; com.tencent.tmgp.yongyong.mrzh (744), de 4,08 GB y sin Zip64; com.xingin.xhs (9510803), con binarios fuera de lib/ y un canal en el bloque de firma; y com.cn21.ecloud (638), protegida con Ijiami. Con 100 apps no podemos extender esto a todo el mercado chino.

4. Los cuatro niveles de «decompilar»

«Decompilar un APK» se dice de cuatro operaciones distintas. Lo que las separa es cuánta información se inventa el que las hace. Confundirlas sale caro: acabas confiando en una salida que puede no corresponderse con lo que la aplicación hace.

Un aviso para quien empieza: no toda la lógica de una app está en el DEX. En una app de Flutter, de Unity o de React Native, buena parte del código está en otro sitio (libapp.so, libil2cpp.so, index.android.bundle), y los niveles 3 y 4 solo ven la parte que quedó en Java o Kotlin. Y no es un caso raro: más de un tercio de las apps más instaladas de Play, y dos de cada tres de las chinas, llevan algún marco de este tipo (Flutter abunda en F-Droid; Unity, en Play). Se reconocen por sus marcas: bibliotecas, ficheros de assets/ y carpetas.

4.1 Nivel 1 — Desempaquetar: unzip -d salida/ app.apk

Abrir el ZIP y sacar los ficheros. Sin pérdida y trivial: los bytes que salen son exactamente los que estaban. Solo se pierde la información del propio contenedor: el orden de las entradas, el método de compresión, el relleno de alineación y el APK Signing Block (que no es una entrada del ZIP, así que unzip ni lo ve). Si vas a volver a montar el APK, necesitas todo eso; si solo quieres mirar dentro, no. apktool d -s -r se queda también en este nivel: copia classes*.dex, resources.arsc y el manifiesto sin tocarlos. Con -s solo, apktool deja el DEX sin desensamblar pero sigue decodificando los recursos, y eso ya es el nivel 2.

4.2 Nivel 2 — Decodificar: apktool d -s (o APKEditor, sobre ARSCLib)

Convertir los formatos binarios de Android a algo legible: AXML a XML de texto, resources.arsc a un árbol res/values/. Reversible en el sentido que importa: la información está toda ahí, y el árbol que escriben apktool o APKEditor se puede volver a compilar. aapt2 dump xmltree y aapt2 dump resources enseñan lo mismo, pero su salida es para leerla, no la entrada de ninguna herramienta. Lo que no se recupera es la forma del fuente (indentación, comentarios, si un booleano se escribió true o TRUE), porque el compilador nunca la guardó. Dos manifiestos distintos pueden producir el mismo AXML, y un AXML admite varias reconstrucciones igualmente válidas.

4.3 Nivel 3 — Desensamblar: baksmali disassemble (o dexdump -d)

Convertir el DEX a «smali», la sintaxis de texto del «bytecode Dalvik». El smali es el DEX escrito como texto: fiel, y editable. Fiel en instrucciones y registros: cada instrucción del fichero es una línea del texto y viceversa. El ensamblador del mismo nombre, smali, vuelve a convertir ese texto en DEX, y por eso es el nivel al que se edita una aplicación de la que no se tiene el fuente. No se inventa nada; lo que falta ya se había perdido al compilar. Los nombres de las variables locales y los números de línea solo están si el compilador los dejó en el campo debug_info_item. Y aquí hay una sorpresa: un ofuscador no lo pone a cero. R8 conserva el debug_info de casi todos los métodos, pero quita los nombres de variables y sustituye los números de línea por la posición dentro del método más uno. El número real solo se recupera con el mapping.txt, que no viaja en el APK. Estas son las medianas, por app, de la fracción de métodos con debug_info:

Ofuscadas Sin ofuscar
F-Droid 0,995 0,910
IzzyOnDroid 0,994 0,903
Google Play, las más instaladas 0,998 0,904
Google Play, sorteo 0,946 0,871

El debug_info está casi siempre, ofuscada o no la app («ofuscada» es aquí una app con el 50 % o más de sus identificadores de 3 caracteres o menos, «sección 5 · Qué sobrevive siempre a la ofuscación»). Lo que cambia es el contenido. En las ofuscadas no queda prácticamente ningún nombre de variable, y en nueve de cada diez métodos la tabla de líneas es la de R8, «línea = posición más uno»; en las sin ofuscar esa tabla casi no aparece. El nombre del fichero fuente (SourceFile) se conserva en algo menos de la mitad de las apps.

Lo que no vuelve es el fichero. El DEX reensamblado no es byte a byte el original: cambia el orden de las secciones, y con él el map_list y todos los offsets, y caen las cadenas que ningún código usa. Aun así, con smali de vuelta salen las mismas clases y métodos en todos los DEX que probamos, salvo uno: el classes3.dex de Viber 9.6.5.5 (de sus 8.842 clases, smali mantiene las clases pero no los métodos). Ver «Desensambladores smali → §6.4 · El viaje de ida y vuelta, medido».

Ejecutado con baksmali 3.0.7 sobre el primer DEX de Droid-ify 0.7.8 (com.looker.droidify, versión 780), de 6,7 MB (6.665.956 bytes):

unzip -o -q com.looker.droidify_780.apk 'classes*.dex' -d dex/
baksmali disassemble dex/classes.dex -o smali/
find smali -name '*.smali' | wc -l
    6456

Seis mil cuatrocientos cincuenta y seis ficheros de texto, uno por clase, con 80,6 MB: unas 12 veces el tamaño del DEX. Por eso este nivel se consulta con grep, no se lee. Tampoco es lento: un DEX de este tamaño tarda unos cinco segundos de mediana. En los 551 DEX que medimos, el número de ficheros .smali es siempre el de class_defs_size, y ninguno terminó con error.

La 3.0.7, de mayo de 2024, no es la última: la serie va hoy por la 3.0.10, del 4 de septiembre de 2026 («sección 3.2 de Mapa del ecosistema · Google y AOSP»). La orden y sus opciones son las mismas en todas: de la 3.0.7 a la 3.0.10 no cambia ningún fichero de las órdenes de baksmali. Sí cambia dexlib2, la biblioteca que lee el DEX, y con ella el recuento no lo hemos repetido (recuadro de la «sección 1 · Qué es un APK»).

4.4 Nivel 4 — Decompilar: jadx -d salida/ app.apk

Convertir el DEX en algo que se parezca a Java. Esto no es una traducción: es una reconstrucción. El bytecode Dalvik está basado en registros y el compilador ya destruyó la estructura del fuente: los bucles son saltos, las constantes pequeñas se fundieron dentro de las instrucciones, las lambdas se convirtieron en clases sintéticas, los genéricos solo sobreviven si quedó la anotación dalvik.annotation.Signature. El decompilador tiene que inferir un programa Java cuyo bytecode sea equivalente al que ve, con tres consecuencias que hay que asumir:

  1. Puede fallar, y falla por método, no por fichero. Lo normal es obtener un .java con casi todos los métodos reconstruidos y unos pocos sustituidos por un comentario de error y el smali original. Probamos jadx 1.5.6 (con apktool 3.0.3 y un límite de 900 s) en una submuestra de 117 piezas, una pieza base por app. Fallan pocos métodos, en torno al 0,2 % de mediana, y ninguna pieza llega al 1 %. Pero casi todas tienen alguno. Con las apps grandes, además, jadx no siempre termina (más de 900 s o sin memoria); le pasa, por ejemplo, con la pieza base.apk del .apkm de com.mercadolibre 10.583.2. Las fracciones solo cuentan las piezas en que jadx terminó.
  2. Lo que sale no compila necesariamente. Y no siempre por un fallo de la herramienta: los nombres admisibles en un DEX son mucho más permisivos que los de Java, así que un ofuscador puede emitir identificadores que no existen como código Java válido. El DEX de Google Maps Lite, por ejemplo, define las clases Ldo; y Lif;, que en Java son palabras reservadas (com.google.android.apps.mapslite 165.0, comprobado con dexdump). APKiD marca esta situación («illegal class name») en casi una de cada cinco apps más instaladas de Play, y casi nunca fuera. La etiqueta no lo ve todo: la app com.output1.learn.daily.spoken.english.urdu (del sorteo de Play, pieza base.apk) también tiene clases do e if y APKiD no las marca. Hay también nombres que Java no admite creados por D8 (j$/…$-CC) y por Kotlin (métodos con guion).
  3. Los fallos son silenciosos si no los buscas. Nadie avisa de qué porcentaje del código que estás leyendo no es lo que la aplicación hace.

4.5 Tabla resumen

Nivel Qué hace Herramienta típica Reversible Qué se pierde
1 · Desempaquetar ZIP → ficheros unzip, apktool d -s -r, APKEditor Sí, con cuidado Orden, compresión, alineación, APK Signing Block
2 · Decodificar AXML → XML, .arsc → res/values/ apktool, ARSCLib (aapt2 dump, solo para leer) Sí Formato del fuente: indentación, comentarios, mayúsculas
3 · Desensamblar DEX → smali baksmali, dexdump -d Sí, en instrucciones y registros; el DEX reensamblado no es byte-idéntico Nada nuevo: los nombres de locales y las líneas ya se habían perdido al compilar
4 · Decompilar DEX → Java jadx, dex2jar + Vineflower/CFR, JEB No La certeza. El resultado es una hipótesis, y puede fallar por método

4.6 El mismo método, en los cuatro niveles

Sobre el APK de ocho pasos de la «sección 2.6 · El ciclo entero, ejecutado», del que conservamos el fuente original:

// nivel 0 · el fuente, que en un APK ajeno no se tiene
android.util.Log.i("EJEMPLO", getString(R.string.app_name));
// nivel 3 · dexdump -d sobre classes.dex
0000: invoke-super {v0, v1}, Landroid/app/Activity;.onCreate:(Landroid/os/Bundle;)V
0003: const/high16 v1, #int 2130771968 // #7f01
0005: invoke-virtual {v0, v1}, L…/MainActivity;.getString:(I)Ljava/lang/String;
0008: move-result-object v0
0009: const-string v1, "EJEMPLO" // string@0010
000b: invoke-static {v1, v0}, Landroid/util/Log;.i:(…)I
000e: return-void

R.string.app_name ya no existe. Lo que queda es la constante 2130771968 = 0x7f010000 incrustada en la instrucción. El nombre del recurso no está en el DEX: está en la tabla de recursos, y es el nivel 2 el que lo devuelve.

// nivel 2 · aapt2 dump resources sobre el mismo APK
Package name=com.ejemplo.demo id=7f
  type string id=01 entryCount=1
    resource 0x7f010000 string/app_name
      () "Ejemplo Demo"

Esa es la lección de la sección entera: los niveles no son etapas de una escalera, son fuentes de información distintas, y el análisis serio los cruza. El nivel 4 solo puede escribir getString(R.string.app_name) porque alguien le ha dado la tabla del nivel 2.

El resto de la salida de dexdump sobre ese mismo método dice qué más se recuperó y qué no:

      positions   :  0x0000 line=4   ·   0x0005 line=5
      locals      :  reg=0 this L…/MainActivity;  ·  reg=1 (null) Landroid/os/Bundle;

Los números de línea sobrevivieron —d8 --release los conserva para que las trazas de pila sean legibles—, pero el nombre del parámetro es (null): se perdió dos veces, porque javac sin -g no escribe la tabla de variables locales y d8 --release la descarta aunque venga; con javac -g y d8 --debug, el nombre llega al DEX. Un decompilador lo llamará bundle, arg0 o p1 según su heurística, y ninguna de las tres es el nombre que escribió el desarrollador. Y eso, en un APK sin ofuscar. Con R8 en modo completo se pierden además los nombres de clases, campos y métodos, y la única vía de vuelta es el mapping.txt, que no viaja dentro del APK.

5. Qué sobrevive siempre a la ofuscación

Aunque el código sea casi ilegible, hay cosas que no se pueden ocultar sin romper la aplicación. Es el suelo del análisis, y conviene tenerlo claro antes de invertir horas en decompilar.

Ninguna app lo oculta todo. La que más nombres cortos tiene en el muestrario es una de F-Droid (com.k2040.escaagnellis, versión 41), con el 95,3 % de los identificadores de su primer DEX de tres caracteres o menos; ninguna llega al 100 %. Ojo al leer esta cifra: mide nombres cortos de clases de primer nivel, métodos y campos, no ofuscación. Una app sin ofuscar también tiene nombres cortos (id, get, x). Aquí llamamos «ofuscada» a una app con el 50 % o más. Las apps con el máximo de cada otro grupo:

  • Sorteo de Play (93,6 %): com.output1.learn.daily.spoken.english.urdu, pieza base.apk.
  • IzzyOnDroid (91,9 %): es.hegocre.scorecounter (versión 361500001).
  • Play, las más instaladas (89,3 %): com.dsi.ant.plugins.antplus 3.9.0.
  • Webs de autores (86,9 %): com.brave.browser, el Bravearm64Universal.apk.
  • Mercado chino (81,2 %): com.pingan.carowner (versión 4480).
Qué sobrevive Por qué no se puede ocultar
El nombre del paquete, la versión, minSdk y targetSdk El instalador los lee antes de ejecutar nada
Los permisos Los concede el sistema a partir del manifiesto. Un permiso no declarado no se obtiene
Los componentes exportados (activity, service, receiver, provider) Otras aplicaciones y el propio sistema tienen que poder resolverlos por nombre
La firma y la cadena de certificados Es lo que el sistema verifica. Es además el identificador estable del autor entre versiones
Los recursos y su estructura Se resuelven por identificador numérico en tiempo de ejecución. Los nombres se pueden ofuscar o colapsar a uno genérico, y algunas apps lo hacen (16 de 658 en Play); la tabla, el conjunto de idiomas, de densidades y los valores, no
Las bibliotecas nativas y sus ABIs El cargador las busca en lib/<abi>/ por convención de ruta, aunque una app puede llevar código nativo en otro sitio y cargarlo por su cuenta
Las llamadas a la API de Android Landroid/... no se puede renombrar: lo define el framework, no la aplicación. Pero basta con que esté en el DEX que se ejecuta: la reflexión con nombres cifrados y los packer la sacan del DEX que viaja en el APK («Ofuscadores comerciales», secciones «2.8» y «8.3»)
Las cadenas que llegan al sistema URLs, nombres de fichero y nombres de tabla se pueden cifrar en reposo, pero tienen que estar en claro en el momento de usarse

Sobre los recursos: todas las apps del muestrario llevan resources.arsc, con sus idiomas y densidades de pantalla a la vista, y casi ninguna colapsa los nombres. F-Droid 2.0.2, por ejemplo, trae 45 idiomas y 7 densidades, y sus 4.809 nombres de recurso intactos.

Sobre las bibliotecas nativas, un aviso: el cargador las busca en lib/<abi>/, pero eso no impide llevarlas en otro sitio. En 79 de las 100 apps chinas hay algún binario ELF fuera de esa carpeta, casi siempre en assets/ y sin la extensión .so; si buscas solo por la extensión, se te escapan dos de cada tres. Fuera del mercado chino es raro. Ejemplos: com.xingin.xhs (versión 9510803, mercado chino) lleva assets/libwbsafeedit, assets/libwbsafeedit_64 y assets/libwbsafeedit_x86, que son ELF sin extensión .so; y org.bitbucket.watashi564.combapp (versión 4, F-Droid) lleva res/5x.so y res/yG.so. Esto no dice nada sobre qué carga la app al ejecutarse.

De ahí sale la regla práctica: el manifiesto, la firma, el inventario del ZIP y las llamadas al framework dan un perfil completo del comportamiento observable de la aplicación sin decompilar una sola línea. Ni siquiera un «packer» se libra. Cambia el DEX original por uno pequeño (un stub) que, al arrancar, descifra el código real y se lo entrega a Android. Pero tiene que declarar en el manifiesto sus permisos y componentes, y tiene que entregar un DEX al runtime: con DexClassLoader, con InMemoryDexClassLoader o manipulando directamente las estructuras de ART. Las tres vías están en «Packers y protectores → §3.2 · Las tres vías de carga». Que el protector entregue el DEX de una de esas tres formas es una afirmación sobre la ejecución, y nosotros solo hemos medido el muestrario de forma estática.

Anatomía de un APK protegido. Se ve en el inventario, y es casi exclusivo del mercado chino: llevan un protector (una familia con prueba fuerte, sin contar PairIP) 38 de sus 100 apps, frente a un 2 % de las más instaladas de Play y ninguna de F-Droid. La señal más clara es un DEX diminuto, de menos de 100 clases. La familia más común es Bangcle/SecNeo (21 de las 38). En Google Play lo que se extiende es PairIP, de Google, sobre todo fuera de las apps más instaladas (27 % del sorteo). Tres ejemplos:

  • com.cn21.ecloud (versión 638, mercado chino), Ijiami: 3 clases, un DEX de 10.136 bytes, una Application que no es suya (s.h.e.l.l.S) y las .so libexec.so, libexecmain.so y libijm-emulator.so.
  • com.able.wisdomtree (versión 272, mercado chino), Jiagu 360: 4 clases en el DEX y Application com.stub.StubApp.
  • com.chinalife.ebz (versión 273, mercado chino), Bangcle/SecNeo: 7 clases, Application com.secneo.apkwrapper.AW y libDexHelper.so.

La heurística no comprueba que el DEX se haya cambiado por un stub. Con APKiD la cifra es parecida (40 de las 98 chinas que pudo leer), y las dos medidas coinciden en 93 de esas 98. Las referencias a la carga dinámica de DEX (DexClassLoader, InMemoryDexClassLoader, DexFile.loadDex o BaseDexClassLoader) no sirven de señal: aparecen en dos de cada tres apps de Play y de las chinas. Además son referencias estáticas y no prueban que se llamen.

Lo que sí desaparece: los nombres de clases, campos y métodos propios; los nombres de las variables locales y de los parámetros; los números de línea del fuente (R8 deja unos números, pero son la posición dentro del método más uno, «sección 4.3 · Nivel 3 — Desensamblar: baksmali disassemble (o dexdump -d)»); a menudo, el nombre del fichero fuente («sección 4.3 · Nivel 3 — Desensamblar: baksmali disassemble (o dexdump -d)»); los genéricos; los nombres de las entradas de recurso; y la estructura del código, si hay aplanamiento de flujo de control. Ver «R8 y ProGuard» y «Anti-análisis y hardening».

La tabla de esta sección es la versión conceptual; la completa está en «Ofuscadores comerciales → §8 · Qué NO se puede ofuscar».

6. Mapa de lectura

Esta tabla organiza la lectura por pregunta concreta, con la sección de este documento que la enmarca.

Lo que quieres hacer Empieza aquí Y sigue por
Saber qué hace la aplicación sin tocar el código («§3», «§5») «Pipeline de análisis» «XML binario (AXML)»
Averiguar qué es ese .xapk / .apks / .apkm («§2.8 · Dónde encaja el AAB») «AAB, splits y contenedores → §6 · Detección por estructura, nunca por extensión» «Fusión de splits»
Leer el código — decide antes el nivel («§4 · Los cuatro niveles de “decompilar”») «Decompiladores a Java» (nivel 4) «Desensambladores smali» (nivel 3)
Modificar la aplicación y que se instale («§2.5 · Empaquetado, alineación y firma») «Pipeline de modificación» «Firma y empaquetado»
Escribir un parser «Contenedor ZIP» «Código fuente de referencia»
Enfrentarte a código ofuscado («§5 · Qué sobrevive siempre a la ofuscación») «R8 y ProGuard» «Deofuscación»
Entender por qué ha fallado algo «Diagnóstico de fallos» —
Elegir herramienta, y saber si sigue viva «Mapa del ecosistema» «Comparativa y selección»
Buscar una palabra «Glosario» —
Saber de dónde salen las cifras «El muestrario» —
Saber qué rechaza la plataforma «Qué rechaza cada lector» —

Fuentes

  1. Build your app from the command line — Android Developers — https://developer.android.com/build/building-cmdline Consultado el 12 de agosto de 2026. De aquí salen los nombres de tarea assembleDebug, assembleRelease y bundle<Variante> («sección 2.7 · Los nombres de las tareas de Gradle») y la generación de claves con keytool (2.6).
  2. AAPT2 — Android Developers — https://developer.android.com/tools/aapt2 Consultado el 12 de agosto de 2026. De aquí salen la cita sobre las dos fases compile y link, la tabla de tipos de fichero .flat, la nota de que el APK que produce link no contiene DEX ni firma, y las opciones --no-crunch, -I y --java («sección 2.2 · Los recursos: aapt2 compile y aapt2 link»).
  3. d8 — Android Developers — https://developer.android.com/tools/d8 Consultado el 12 de agosto de 2026. De aquí salen la definición de D8 y las opciones --release, --min-api y --lib (secciones «2.3» y «2.6»).
  4. Enable app optimization with R8 — Android Developers — https://developer.android.com/topic/performance/app-optimization/enable-app-optimization Consultado el 12 de agosto de 2026; la URL developer.android.com/build/shrink-code redirige aquí. De aquí salen las tres operaciones de R8, el ejemplo com.example.MyActivity → a.b.a, el full mode por defecto desde AGP 8.0 y el bloque optimization {} de AGP 9.3 («sección 2.3 · El código: javac/kotlinc, y luego D8 o R8»). Vuelto a consultar el 18 de octubre de 2026: de aquí sale además que en AGP 9.3 son nuevos el bloque optimization {} y el source set keepRules («sección 2.3 · El código: javac/kotlinc, y luego D8 o R8»).
  5. Android Gradle plugin 9.3.0 release notes (julio de 2026) — https://developer.android.com/build/releases/gradle-plugin Consultado el 12 de agosto de 2026. De aquí sale que la rama estable de AGP el día de la consulta es la 9.3, con Gradle 9.5.0, SDK Build Tools 36.0.0 y JDK 17 («sección 2.7 · Los nombres de las tareas de Gradle»).
  6. zipalign — Android Developers — https://developer.android.com/tools/zipalign Consultado el 12 de agosto de 2026. De aquí salen la cita sobre mmap(2), la regla de -P 16 para los .so y el orden respecto a apksigner («sección 2.5 · Empaquetado, alineación y firma»).
  7. apksigner — Android Developers — https://developer.android.com/tools/apksigner Consultado el 12 de agosto de 2026. De aquí salen la sintaxis de sign y verify y la advertencia de que modificar el APK tras firmarlo invalida la firma (secciones «2.5» y «2.6»).
  8. About Android App Bundles — Android Developers — https://developer.android.com/guide/app-bundle Consultado el 12 de agosto de 2026. De aquí sale la definición citada del AAB como formato de publicación que difiere la generación y la firma de los APK a Google Play («sección 2.8 · Dónde encaja el AAB»).
  9. Ejecución local del ciclo de build y de los cuatro niveles — build-tools 37.0.0 (aapt2 2.20-15087165, D8 9.2.4-dev, apksigner 0.9, zipalign, dexdump), javac 21.0.10 y platforms/android-35, el 12 de agosto de 2026 sobre un proyecto mínimo. De aquí salen las salidas de las secciones «2.6» y «4.6». No salen del muestrario.
  10. baksmali 3.0.7 — https://github.com/google/smali Instalado y ejecutado sobre el primer DEX de com.looker.droidify_780.apk del muestrario. De aquí sale la salida de la «sección 4.3 · Nivel 3 — Desensamblar: baksmali disassemble (o dexdump -d)».
  11. ApkLiteParseUtils.java y ApkAssets (AOSP, android-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/content/pm/parsing/ApkLiteParseUtils.java Consultado el 18 de octubre de 2026. De aquí sale que, si falta el manifiesto, ApkAssets.openXml() lanza FileNotFoundException, que parseApkLiteInner convierte en INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION (−102) («sección 1 · Qué es un APK»).
  12. Android Gradle Plugin 8.0.0 release notes — https://developer.android.com/build/releases/past-releases/agp-8-0-0-release-notes Consultado el 18 de octubre de 2026. De aquí salen la fecha de AGP 8.0.0, abril de 2023, y que android.enableR8.fullMode pasa a true por defecto («sección 2.3 · El código: javac/kotlinc, y luego D8 o R8»).
  13. Android Gradle Plugin 4.2.0 release notes — DEX files uncompressed in APKs when minSdk = 28 or higher — https://developer.android.com/build/releases/past-releases/agp-4-2-0-release-notes Consultado el 18 de octubre de 2026. De aquí sale que AGP empaqueta los DEX sin comprimir por defecto cuando minSdk es 28 o más («sección 3.4 · Lo que cambia en un APK más moderno»).
  14. V1SchemeSigner.java (AOSP, apksig, android-17.0.0_r1) — https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/main/java/com/android/apksig/internal/apk/v1/V1SchemeSigner.java Consultado el 18 de octubre de 2026. De aquí sale getSafeSignerName(): el nombre del firmante se pasa a mayúsculas, se corta a ocho caracteres y todo carácter fuera de A-Z, 0-9, - y _ se cambia por _. Junto a la página de apksigner (fuente 7, vuelta a consultar ese día para la opción --v1-signer-name), que dice que ese nombre es por defecto el alias de la clave, da la regla de la «sección 3.3 · Categoría por categoría».
  15. Ida y vuelta de smali y modos de D8 sobre una clase de prueba — build-tools 37.0.0 (D8 9.2.4-dev, dexdump), javac 21.0.10 y baksmali/smali 3.0.7, ejecutado el 18 de octubre de 2026 sobre una clase de diez líneas con un campo, un bucle y un main. De aquí salen dos cosas. Que el DEX que reensambla smali desensambla a un árbol smali idéntico (diff -r vacío) pero no es el mismo fichero: otro orden de las secciones de datos en el map_list, otros offsets y una cadena menos, el marcador ~~D8{…} que D8 deja en su salida («sección 4.3 · Nivel 3 — Desensamblar: baksmali disassemble (o dexdump -d)»). Y que d8 --release emite los parámetros sin nombre y ninguna variable local aunque javac -g haya escrito la LocalVariableTable, mientras que d8 --debug los conserva; javac sin -g solo escribe números de línea y fichero fuente («sección 4.6 · El mismo método, en los cuatro niveles»). La página de d8 (fuente 3) lo dice así: --release compila «without debug information».
  16. APK Signature Scheme v2 — Android Open Source Project — https://source.android.com/docs/security/features/apksigning/v2 Consultado el 18 de octubre de 2026 (página actualizada el 30 de septiembre de 2026). De aquí sale que la firma v2 protege los tramos 1, 3 y 4 del APK —el contenido de las entradas, el Central Directory y el EOCD— y, del tramo 2, el APK Signing Block, solo los bloques signed data de la propia firma v2 («sección 2.5 · Empaquetado, alineación y firma»).
  17. Páginas de 16 KB — blog y guía de Android — https://android-developers.googleblog.com/2025/05/prepare-play-apps-for-devices-with-16kb-page-size.html y https://developer.android.com/guide/practices/page-sizes Consultados el 18 de octubre de 2026. Del blog, del 8 de mayo de 2025, sale el 1 de noviembre de 2025 para las aplicaciones nuevas y las actualizaciones; de la guía, actualizada el 16 de octubre de 2026, el 1 de febrero de 2027 para las actualizaciones, con targetSdk 35 o superior y dispositivos de 64 bits («sección 3.4 · Lo que cambia en un APK más moderno»).
  18. aapt2: format/Container.cpp y cmd/Compile.cpp (AOSP, android-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/tools/aapt2/format/Container.cpp y https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/tools/aapt2/cmd/Compile.cpp Consultados el 18 de octubre de 2026. De aquí sale el formato del .flat: la marca 0x54504141 (AAPT) y la versión 1 en cabecera, entradas de tipo tabla (kResTable) o fichero (kResFile), y en estas una cabecera CompiledFile en protobuf seguida del contenido; FlattenXmlToOutStream serializa el XML como pb::XmlNode, CompilePng escribe la imagen procesada y CompileFile, el resto tal cual («sección 2.2 · Los recursos: aapt2 compile y aapt2 link»). La página de AAPT2 (fuente 2) describe esos ficheros como «binary XML files with *.flat extensions».
  19. Apktool v3.0.3 — Main.java y ApkDecoder.java — https://github.com/iBotPeaches/Apktool/blob/v3.0.3/brut.apktool/apktool-cli/src/main/java/brut/apktool/Main.java y https://github.com/iBotPeaches/Apktool/blob/v3.0.3/brut.apktool/apktool-lib/src/main/java/brut/androlib/ApkDecoder.java Consultados el 18 de octubre de 2026 vía la API de GitHub. De aquí salen las opciones -s («Do not decode sources.») y -r («Do not decode resources.»), y que con -r apktool copia en crudo resources.arsc y AndroidManifest.xml, y con -s, los classes*.dex («sección 4.1 · Nivel 1 — Desempaquetar: unzip -d salida/ app.apk»).
  20. google/smali: versiones en el Maven de Google y comparación 3.0.7…3.0.10 — https://dl.google.com/android/maven2/com/android/tools/smali/smali-baksmali/maven-metadata.xml y https://api.github.com/repos/google/smali/compare/3.0.7...3.0.10 Consultados el 18 de octubre de 2026. De aquí salen las fechas de la 3.0.7 (14 de mayo de 2024), la 3.0.9 (20 de diciembre de 2024) y la 3.0.10 (4 de septiembre de 2026), según la cabecera Last-Modified del .jar de cada versión, y que entre la 3.0.7 y la 3.0.10 —34 commits, 48 ficheros— lo único que cambia bajo baksmali/ es Android.bp, mientras que sí cambian ficheros de dexlib2 («sección 4.3 · Nivel 3 — Desensamblar: baksmali disassemble (o dexdump -d)»).
  21. El muestrario de octubre de 2026 — descargado entre el 19 y el 27 de octubre de 2026 y descrito en «El muestrario». De aquí salen las cifras y los ejemplos de las secciones «1», «2», «3», «4» y «5». Para repetir las cifras: MUESTRARIO_RAIZ=<carpeta del muestrario> python3 -I scripts/muestrario/cifras/<script>.py --salida <fichero.json>.