Anatomía de un APK
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.
storedydeflate: los dos métodos de compresión que usa un APK.storedguarda la entrada sin comprimir;deflatela 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.xmlderes/.DEX: el formato del código que ejecuta Android, en ficherosclasses*.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 unbase.apkmás variossplit.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.sosin comprimir (40.952 bytes) ystamp-cert-sha256. No hayDEXniresources.arsc. - Pieza
split_config.xxhdpi.apk, de densidad: unresources.arscde 11.476 bytes sin comprimir y 57 recursos (46.pngy 11.webp). - Pieza
base.apk, la base de la misma app: 1.339 entradas y unclasses.dexsin 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:
- No es un
AAB. El Android App Bundle es un formato de publicación, no de instalación, y por dentro usa Protocol Buffers en vez de los formatos binarios de Android. Ver la «sección 2.8 · Dónde encaja el AAB» y «AAB, splits y contenedores». - No es necesariamente un fichero. Desde el App Bundle, una aplicación instalada suele ser
un
base.apkmás variossplit. Es lo normal en Google Play: llegan en varias piezas siete de cada diez de las apps más instaladas. Fuera de Play no lo hace ninguna; F-Droid, IzzyOnDroid, el mercado chino y las webs de autores sirven un solo APK («sección 2.9 · Una app de Play tal como queda en el móvil»). Si descargas de un sitio de terceros un.apkmo un.xapk, lo que tienes es un ZIP con varios APK dentro: una docena de mediana en los de APKMirror, tres en los de APKPure. El.apkses el contenedor que producebundletool; en el muestrario no hay ninguno («sección 2.8 · Dónde encaja el AAB»). - No contiene el
.odex, el.vdexni el.oat. Esos los generadex2oaten el dispositivo al instalar. Ver «Artefactos auxiliares → §5 · El lado del dispositivo: dex2oat, .odex, .vdex, .oat, .art». En el muestrario no aparece ninguno, ni por el nombre ni por los primeros bytes del fichero.
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.
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.
2.2 Los recursos: aapt2 compile y aapt2 link
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,zipalignmust be used before the APK file has been signed. If you sign your APK usingapksignerand 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:
apksignergeneró un.idsigsin pedírselo. La firma v4 vive en un fichero acompañante, fuera del APK, yapksigner verifyno la mira salvo que le pases--v4-signature-file.v1: falseno significa que no haya firma v1. El APK resultante contieneMETA-INF/MANIFEST.MF,META-INF/DEMO.SFyMETA-INF/DEMO.RSA. Lo que diceapksigneres que, conminSdkVersion24, la verificación no necesita v1: si repites la orden con--min-sdk-version 21, respondev1: true. Pasa igual con un APK del muestrario: el cliente de F-Droid 2.0.2, conminSdk24, traeMETA-INF/CIARANG.SFyCIARANG.RSA, yapksigner verify -vrespondev1: false,v2: true,v3: true,v3.1: false,v3.2: falseyv4: false.- 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.
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 piezabase.apkdel.apkmde Google Play (2.26.42.9). - Firefox: el APK
arm64-v8ade 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.apkde la web del autor y la piezabase.apkde 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=FDroiden un sitio yCN=Mohit Sharmaen 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. - WhatsApp: el APK de la web del autor (
-
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.socomprimidas ystamp-cert-sha256. - Pieza
split_config.xhdpi.apk, de densidad, 64.162 bytes: 47 entradas,res/ystamp-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.dexsin comprimir de 6.531.232 bytes yresources.arscde 570.040 bytes.split_config.arm64_v8a.apk: manifiesto, 3.so(40.952 bytes) ystamp-cert-sha256.split_config.xxhdpi.apk:resources.arscde 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.apkdel.apkmde TikTok (com.zhiliaoapp.musically47.4.16), con el paquete0x56. - Paquete de datos: la pieza
split_install_time_asset_pack.apkdecom.xd.muffin.gp.global, de 3,75 GB y 17.463 entradas, el mayor del muestrario. - Paquete de datos: la pieza
split_UnityStreamingAssetsPack.apkdel.apkmdecom.igg.android.lordsmobile2.206, de 2,12 GB. - Un
.obb: el.apkmdecom.zakg.scaryteacher.hellgame10.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:
- La firma v1 sobra si
minSdkes 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: conminSdk24 o más, más de la mitad de las apps de F-Droid la siguen llevando, aunque en Play ya es minoritaria. ConminSdkmenor de 24 la llevan todas, sin excepción. - Los
DEXsin comprimir los hace AGP por defecto desde la versión 4.2 siminSdkes 28 o más («Contenedor ZIP → §9 · Métodos de compresión»). Con eseminSdklo 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. apksigner verifysolo comprueba lo que necesita para eseminSdk. En Lumo respondev1: falseyv2: true, y nada más. Endev.kaleve.nonius(versión 6,minSdk36) respondev1: false,v2: falseyv3: true. El cliente de F-Droid 2.0.2 (minSdk24) lleva v1 sin necesitarla yapksignerrespondev1: false,v2: trueyv3: true. Queapksignerverifique o no una pieza depende además de la versión de Java y delminSdkdeclarado, 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.apkde los.apkmdecom.heytap.music48.15.1.60.0 y decom.oppo.music58.15.1.58.5, sin veredicto: sulib/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 conapksigner. 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:
- Puede fallar, y falla por método, no por fichero. Lo normal es obtener un
.javacon casi todos los métodos reconstruidos y unos pocos sustituidos por un comentario de error y elsmalioriginal. Probamosjadx1.5.6 (conapktool3.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,jadxno siempre termina (más de 900 s o sin memoria); le pasa, por ejemplo, con la piezabase.apkdel.apkmdecom.mercadolibre10.583.2. Las fracciones solo cuentan las piezas en quejadxterminó. - Lo que sale no compila necesariamente. Y no siempre por un fallo de la herramienta: los
nombres admisibles en un
DEXson mucho más permisivos que los de Java, así que un ofuscador puede emitir identificadores que no existen como código Java válido. ElDEXde Google Maps Lite, por ejemplo, define las clasesLdo;yLif;, que en Java son palabras reservadas (com.google.android.apps.mapslite165.0, comprobado condexdump). 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 appcom.output1.learn.daily.spoken.english.urdu(del sorteo de Play, piezabase.apk) también tiene clasesdoeify APKiD no las marca. Hay también nombres que Java no admite creados porD8(j$/…$-CC) y por Kotlin (métodos con guion). - 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, piezabase.apk. - IzzyOnDroid (91,9 %):
es.hegocre.scorecounter(versión 361500001). - Play, las más instaladas (89,3 %):
com.dsi.ant.plugins.antplus3.9.0. - Webs de autores (86,9 %):
com.brave.browser, elBravearm64Universal.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
DEXdiminuto, 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, unDEXde 10.136 bytes, unaApplicationque no es suya (s.h.e.l.l.S) y las.solibexec.so,libexecmain.soylibijm-emulator.so.com.able.wisdomtree(versión 272, mercado chino), Jiagu 360: 4 clases en elDEXyApplicationcom.stub.StubApp.com.chinalife.ebz(versión 273, mercado chino), Bangcle/SecNeo: 7 clases,Applicationcom.secneo.apkwrapper.AWylibDexHelper.so.La heurística no comprueba que el
DEXse 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 deDEX(DexClassLoader,InMemoryDexClassLoader,DexFile.loadDexoBaseDexClassLoader) 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.
Fuentes
- 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,assembleReleaseybundle<Variante>(«sección 2.7 · Los nombres de las tareas de Gradle») y la generación de claves conkeytool(2.6). - 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 producelinkno contiene DEX ni firma, y las opciones--no-crunch,-Iy--java(«sección 2.2 · Los recursos: aapt2 compile y aapt2 link»). - d8 — Android Developers — https://developer.android.com/tools/d8
Consultado el 12 de agosto de 2026. De aquí salen la definición de
D8y las opciones--release,--min-apiy--lib(secciones «2.3» y «2.6»). - 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-coderedirige aquí. De aquí salen las tres operaciones deR8, el ejemplocom.example.MyActivity→a.b.a, el full mode por defecto desde AGP 8.0 y el bloqueoptimization {}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 bloqueoptimization {}y el source setkeepRules(«sección 2.3 · El código: javac/kotlinc, y luego D8 o R8»). - 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»).
- 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 16para los.soy el orden respecto aapksigner(«sección 2.5 · Empaquetado, alineación y firma»). - apksigner — Android Developers — https://developer.android.com/tools/apksigner
Consultado el 12 de agosto de 2026. De aquí salen la sintaxis de
signyverifyy la advertencia de que modificar el APK tras firmarlo invalida la firma (secciones «2.5» y «2.6»). - 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
AABcomo 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»). - Ejecución local del ciclo de build y de los cuatro niveles —
build-tools37.0.0 (aapt22.20-15087165,D89.2.4-dev,apksigner0.9,zipalign,dexdump),javac21.0.10 yplatforms/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. - baksmali 3.0.7 — https://github.com/google/smali
Instalado y ejecutado sobre el primer
DEXdecom.looker.droidify_780.apkdel muestrario. De aquí sale la salida de la «sección 4.3 · Nivel 3 — Desensamblar: baksmali disassemble (o dexdump -d)». - 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()lanzaFileNotFoundException, queparseApkLiteInnerconvierte enINSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION(−102) («sección 1 · Qué es un APK»). - 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.fullModepasa atruepor defecto («sección 2.3 · El código: javac/kotlinc, y luego D8 o R8»). - 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 losDEXsin comprimir por defecto cuandominSdkes 28 o más («sección 3.4 · Lo que cambia en un APK más moderno»). - 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í salegetSafeSignerName(): el nombre del firmante se pasa a mayúsculas, se corta a ocho caracteres y todo carácter fuera deA-Z,0-9,-y_se cambia por_. Junto a la página deapksigner(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». - Ida y vuelta de
smaliy modos deD8sobre una clase de prueba —build-tools37.0.0 (D89.2.4-dev,dexdump),javac21.0.10 ybaksmali/smali3.0.7, ejecutado el 18 de octubre de 2026 sobre una clase de diez líneas con un campo, un bucle y unmain. De aquí salen dos cosas. Que elDEXque reensamblasmalidesensambla a un árbolsmaliidéntico (diff -rvacío) pero no es el mismo fichero: otro orden de las secciones de datos en elmap_list, otros offsets y una cadena menos, el marcador~~D8{…}queD8deja en su salida («sección 4.3 · Nivel 3 — Desensamblar: baksmali disassemble (o dexdump -d)»). Y qued8 --releaseemite los parámetros sin nombre y ninguna variable local aunquejavac -ghaya escrito laLocalVariableTable, mientras qued8 --debuglos conserva;javacsin-gsolo escribe números de línea y fichero fuente («sección 4.6 · El mismo método, en los cuatro niveles»). La página ded8(fuente 3) lo dice así:--releasecompila «without debug information». - 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, elCentral Directoryy elEOCD— y, del tramo 2, elAPK Signing Block, solo los bloquessigned datade la propia firma v2 («sección 2.5 · Empaquetado, alineación y firma»). - 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
targetSdk35 o superior y dispositivos de 64 bits («sección 3.4 · Lo que cambia en un APK más moderno»). aapt2:format/Container.cppycmd/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 marca0x54504141(AAPT) y la versión 1 en cabecera, entradas de tipo tabla (kResTable) o fichero (kResFile), y en estas una cabeceraCompiledFileen protobuf seguida del contenido;FlattenXmlToOutStreamserializa el XML comopb::XmlNode,CompilePngescribe la imagen procesada yCompileFile, 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*.flatextensions».- Apktool v3.0.3 —
Main.javayApkDecoder.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-rapktool copia en crudoresources.arscyAndroidManifest.xml, y con-s, losclasses*.dex(«sección 4.1 · Nivel 1 — Desempaquetar: unzip -d salida/ app.apk»). 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 cabeceraLast-Modifieddel.jarde cada versión, y que entre la 3.0.7 y la 3.0.10 —34 commits, 48 ficheros— lo único que cambia bajobaksmali/esAndroid.bp, mientras que sí cambian ficheros dedexlib2(«sección 4.3 · Nivel 3 — Desensamblar: baksmali disassemble (o dexdump -d)»).- 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>.