Formato DEX

Antes conviene leer «Anatomía de un APK»

referencia técnica · Actualizado el 15 de noviembre de 2026

1. Qué es y por qué existe

Un fichero DEX (Dalvik EXecutable) contiene todo el código compilado de una aplicación Android: no una clase, sino cientos o miles. Dentro de un APK se llama classes.dex, y con multidex («sección 15 · El límite de 65.536 referencias y multidex») le acompañan classes2.dex y sucesivos.

Ojo: no siempre es todo el código. Cuatro de cada diez apps de las más instaladas de Google Play llevan además un DEX en otra carpeta, y casi siempre es el SDK de anuncios de Meta (assets/audience_network.dex y parientes). En F-Droid solo hemos visto una app así. Y hay apps con protectores donde el classes.dex visible es una cáscara de unas decenas de clases. Lo vemos en la «sección 17 · Cuando el DEX no es todo el código».

Existe porque el .class de la JVM no servía para un teléfono de 2008. En la JVM cada clase es un fichero con su propio constant pool: si mil clases mencionan java.lang.String, la cadena "java/lang/String" aparece mil veces. El DEX invierte el reparto: un fichero, tablas compartidas. Todas las cadenas viven una vez en string_ids; los tipos, en type_ids; los prototipos, en proto_ids; los campos y métodos referenciados, en field_ids y method_ids. Una clase no guarda nombres, guarda índices. Por eso el DEX está pensado para consultarse por índice sin desempaquetar nada: el sistema puede mapearlo en memoria (mmap, que es tratar el fichero como si fuera memoria) y leerlo tal cual.

Eso solo es posible si el DEX va sin comprimir (stored) y alineado a 4 bytes dentro del APK. Si va comprimido, hay que extraerlo antes. Lo que decide en la práctica es el minSdk, la versión mínima de Android que la app dice soportar. Con minSdk 28 o más, casi todas las apps de F-Droid lo llevan sin comprimir (el 97 %); con menos, casi ninguna (el 2 %). Contando todas, en F-Droid va sin comprimir en torno al 14 % de las apps, y en Google Play lo habitual es lo contrario: dos de cada tres de las más instaladas lo llevan sin comprimir. Por ejemplo, com.github.howeyc.crocgui (F-Droid, versión 48) lleva sus DEX stored y alineados, y Droid-ify (com.looker.droidify, versión 780) y Termux (com.termux, versión 1022) los llevan con deflate, el método 8 del ZIP. Estas cifras describen cómo viene el fichero. No sabemos qué hace Android al instalar la app: si mapea el DEX, si lo extrae o si lo compila.

Se paga en dos monedas. Los índices son de 16 bits en el bytecode, de donde sale el límite de 65.536 referencias y con él multidex. Y nada es local: renombrar un método toca string_ids, que está ordenado, lo que desplaza offsets, lo que invalida map_list, el checksum y la signature. Editar un DEX no es editar un fichero, es reconstruirlo. Por eso existen baksmali y smali («Desensambladores smali»), y por eso las herramientas prudentes evitan reescribir el DEX.

.class de la JVM DEX
Unidad de fichero Una clase Todas las clases de la aplicación
Tabla de constantes Una por clase, con duplicados entre clases Global, deduplicada, ordenada
Endianness Big-endian Little-endian
Modelo de ejecución Pila de operandos Registros («Bytecode Dalvik»)
Cadenas CONSTANT_Utf8 MUTF-8, esencialmente lo mismo («sección 8.2 · MUTF-8»)
┌────────────────────────────────────────────────────────────┐
│ header_item                             112 bytes (0x70)   │ offset 0
├────────────────────────────────────────────────────────────┤
│ string_ids    string_id_item[]     4 bytes cada uno        │ ┐
│ type_ids      type_id_item[]       4 bytes                 │ │
│ proto_ids     proto_id_item[]     12 bytes                 │ │
│ field_ids     field_id_item[]      8 bytes                 │ │ tablas de
│ method_ids    method_id_item[]     8 bytes                 │ │ índices
│ class_defs    class_def_item[]    32 bytes                 │ │ (registro fijo,
│ call_site_ids  call_site_id_item[]   4 bytes  ┐ v038+; no  │ │ alineadas a 4)
│ method_handles method_handle_item[]  8 bytes  ┘ en header  │ ┘
├────────────────────────────────────────────────────────────┤
│ data          todo lo de tamaño variable:                  │
│               string_data_item, type_list, class_data_item,│
│               code_item, debug_info_item, anotaciones…     │
│               y el map_list, casi siempre al final         │
├────────────────────────────────────────────────────────────┤
│ link_data     vacío en casi todos los APK                  │
└────────────────────────────────────────────────────────────┘

Ese orden es el habitual, no el obligatorio: lo único fijo es que el header_item va primero y que las entradas del map_list van ordenadas por offset y sin solaparse. La autoridad sobre dónde está cada cosa es el map_list («sección 5 · map_list: la vía fiable de recorrer el fichero»), no este dibujo.

Los DEX reales cumplen el dibujo casi siempre: el map_list va al final en el 99 % de los de F-Droid y en prácticamente todos los de Google Play. Los que lo llevan en otro sitio son sobre todo los generados por dx y dexmerge («sección 5.2 · El orden del map_list como huella»). Un ejemplo de F-Droid es com.juliansparber.captiveportallogin (versión 2): su DEX no tiene marcador de compilador y su última entrada no es el map_list. Y el link_data está vacío en todos los DEX menos uno de más de 16.000: el classes.dex de com.tencent.tgclub (versión 2026081227, mercado chino), de 70.884 bytes, declara link_size 4 y link_off 70.880, es decir, cuatro bytes a cero al final del fichero.

El link_data está vacío en todos los DEX salvo uno de los 16.158. Es el classes.dex de com.tencent.tgclub (versión 2026081227, mercado chino), de 70.884 bytes, que declara link_size 4 y link_off 70.880: cuatro bytes a cero al final del fichero.

1.1 Cómo son los DEX de apps reales

Un DEX real puede ser diminuto o enorme. El de S.N.A.K.E (versión 1000001, F-Droid) mide 5.404 bytes y define 4 clases. Es un buen primer DEX para leer entero («sección 3.1 · La cabecera de un DEX real»). Un DEX típico de F-Droid mide 3,7 MB (mediana de los 7.185). Una app típica de las más instaladas de Google Play suma 44,2 MB de DEX repartidos en 6 ficheros (medianas por app). La tabla da la escala por fuente, siempre con la mediana por app.

Fuente Apps con DEX DEX por app Clases por app method_ids por app (suma) MB de DEX por app
F-Droid 4.765 1 3.891 26.267 3,9
IzzyOnDroid 1.402 1 4.490 28.656 4,2
Google Play, las más instaladas 658 6 46.379 297.001 44,2
Google Play, sorteo 369 3 18.583 124.754 17,3
Mercado chino 100 3,5 20.368 166.232 66,9

Fíjate en el salto: una app de Google Play tiene más de diez veces más clases que una de F-Droid. El código también pesa distinto según de dónde venga. En F-Droid, el DEX es en torno al 40 % del APK comprimido; en el mercado chino baja a menos de una quinta parte, porque allí pesan más las bibliotecas nativas y los assets. Las 7 apps de webs de autores quedan fuera de la tabla.

Dos extremos con nombre. El DEX más grande es el de com.gtgj.view (versión 489, mercado chino), de 167.529.220 bytes y solo 5 clases («sección 17.2 · Protectores: el DEX visible es una cáscara»). La app con más clases es com.ss.android.ugc.aweme (Douyin, versión 400801), con 554.489 clases en 56 DEX. El DEX más pequeño que sale en este documento es el classes2.dex de Termux 1022, de 876 bytes («sección 5 · map_list: la vía fiable de recorrer el fichero»).

Las medidas son del muestrario descargado entre el 19 y el 27 de octubre de 2026. Para repetirlas: MUESTRARIO_RAIZ=<carpeta del muestrario> python3 -I scripts/muestrario/cifras/dex_y_bytecode_1.py --salida <fichero.json> escribe casi todas las cifras de este documento. Las de un solo DEX de ejemplo (Droid-ify 780, Termux 1022 y S.N.A.K.E: anotaciones, bits de access_flags, static_values, deltas de class_data_item y clases repetidas entre dos DEX) salen de MUESTRARIO_RAIZ=<carpeta del muestrario> python3 -I scripts/muestrario/cifras/ejemplos_1.py --salida <fichero.json>.

2. Convenciones del formato

Endianness: little-endian en todo el documento. endian_tag lo declara con ENDIAN_CONSTANT = 0x12345678; su reverso, REVERSE_ENDIAN_CONSTANT = 0x78563412, indicaría un fichero con los bytes intercambiados. No aparece en ninguno de los 16.158 DEX del muestrario. Tampoco hay ningún DEX con file_size distinto del tamaño real del fichero ni con un magic que no se reconozca (0 de 16.158 en cada caso).

Tipo Tamaño Significado
byte / ubyte 1 Entero de 8 bits con y sin signo
short / ushort 2 Entero de 16 bits con y sin signo
int / uint 4 Entero de 32 bits con y sin signo
long / ulong 8 Entero de 64 bits con y sin signo
sleb128 / uleb128 var LEB128 con y sin signo, de 1 a 5 bytes («sección 8.1 · LEB128»)
uleb128p1 var LEB128 sin signo desplazado en uno

Alineación, que no es uniforme y es fuente clásica de fallos: a 4 bytes el header_item, las ocho tablas de índices —las seis que enumera la cabecera más call_site_ids y method_handles—, map_list, type_list, code_item, annotation_set_item, annotation_set_ref_list y annotations_directory_item. Sin alineación (byte a byte) string_data_item, class_data_item, debug_info_item, annotation_item, encoded_array_item y call_site_item.

3. header_item campo a campo

Offsets absolutos, porque la cabecera empieza en el byte 0. Los pares *_size/*_off van en una sola fila: primero el tamaño, luego el offset.

Campo Offset Tamaño Tipo Significado
magic 0x00 8 ubyte[8] DEX_FILE_MAGIC: "dex\n" + tres dígitos de versión + "\0" («sección 4 · magic y la tabla de versiones»)
checksum 0x08 4 uint Adler-32 de todo lo posterior al byte 12: el fichero menos magic y menos este campo
signature 0x0c 20 ubyte[20] SHA-1 de todo lo posterior al byte 32: el fichero menos magic, checksum y esta firma. Identifica el fichero; no autentica a nadie
file_size 0x20 4 uint Tamaño del fichero entero, cabecera incluida (≤ v040). Desde v041, distancia hasta la siguiente cabecera o el fin del contenedor
header_size 0x24 4 uint Debe valer 0x70 (112) hasta v040 y 0x78 (120) desde v041
endian_tag 0x28 4 uint ENDIAN_CONSTANT = 0x12345678
link_size / link_off 0x2c / 0x30 4 + 4 uint Sección link, o 0 si no hay enlazado estático. Formato sin especificar: hueco para el runtime
map_off 0x34 4 uint Offset del map_list. Debe ser distinto de cero
string_ids_size / _off 0x38 / 0x3c 4 + 4 uint Número de cadenas y offset de la tabla, o 0 si el tamaño es 0
type_ids_size / _off 0x40 / 0x44 4 + 4 uint Número de tipos, como máximo 65.535, y offset
proto_ids_size / _off 0x48 / 0x4c 4 + 4 uint Número de prototipos, como máximo 65.535, y offset
field_ids_size / _off 0x50 / 0x54 4 + 4 uint Número de campos referenciados y offset
method_ids_size / _off 0x58 / 0x5c 4 + 4 uint Número de métodos referenciados y offset
class_defs_size / _off 0x60 / 0x64 4 + 4 uint Número de clases definidas aquí —no referenciadas— y offset
data_size / data_off 0x68 / 0x6c 4 + 4 uint Sección data; el tamaño es múltiplo de 4. Ambos sin uso desde v041
container_size 0x70 4 uint Solo v041+. Tamaño del contenedor completo
header_offset 0x74 4 uint Solo v041+. Offset de esta cabecera dentro del contenedor

Tres cosas que no están aquí y sorprenden. call_site_ids y method_handles no tienen campos en la cabecera: llegaron en la versión 038 y no se podía crecer la estructura sin romper la compatibilidad, así que viven solo en el map_list. Todos los offsets son desde el inicio del fichero, no desde la estructura que los contiene. Y class_defs_size cuenta clases definidas aquí, no referenciadas, así que type_ids_size es mayor.

En la práctica, un DEX define unas tres cuartas partes de los tipos que menciona: la mediana del cociente va de 0,69 a 0,80 según la fuente. Nunca llega a 1 en el muestrario, aunque el formato no lo garantiza. A veces se acerca mucho: com.sakethh.jetspacer (IzzyOnDroid, versión 2) tiene 27.847 class_defs para 29.231 type_ids (0,95). Y los DEX de una sola clase dan cocientes bajos: el classes2.dex de Termux 1022 tiene 1 clase y 5 tipos (0,2).

3.1 La cabecera de un DEX real

Para ver una cabecera de verdad hace falta sacar un DEX de un APK. El ejemplo es Droid-ify 0.7.8 (com.looker.droidify, versión 780, de F-Droid), cuyo classes.dex mide 6,7 MB. La copia de IzzyOnDroid trae los mismos DEX («sección 14.1 · El mismo DEX en dos APK»). MUESTRARIO es la carpeta con la copia del muestrario (mira la «sección 9 de El muestrario · Cómo comprobar un ejemplo»).

BT=~/Library/Android/sdk/build-tools/37.0.0
MUESTRARIO=<carpeta del muestrario>
DEXDIR=$(mktemp -d)
unzip -o -q $MUESTRARIO/fdroid/com.looker.droidify_780.apk 'classes*.dex' -d $DEXDIR
xxd -l 128 $DEXDIR/classes.dex
00000000: 6465 780a 3033 3500 504e 4887 7f1b af5a  dex.035.PNH....Z
00000010: 56a9 1ca1 d557 d0df 130d 78c4 f5c0 a967  V....W....x....g
00000020: e4b6 6500 7000 0000 7856 3412 0000 0000  ..e.p...xV4.....
00000030: 0000 0000 14b6 6500 0bac 0000 7000 0000  ......e.....p...
00000040: 6f1f 0000 9cb0 0200 c723 0000 582e 0300  o........#..X...
00000050: db5b 0000 acdb 0400 b493 0000 84ba 0700  .[..............
00000060: 3819 0000 2458 0c00 c037 5600 247f 0f00  8...$X...7V.$...
00000070: d83e 4d00 da3e 4d00 de3e 4d00 2844 4d00  .>M..>M..>M.(DM.

Anotado a mano sobre esos bytes (la cabecera acaba en 0x70, donde ya empieza string_ids):

Offset Bytes Campo Valor
0x00 64 65 78 0a 30 33 35 00 magic "dex\n035\0" → versión 035
0x08 50 4e 48 87 checksum 0x87484e50
0x0c 7f 1b … f5 c0 a9 67 signature 7f1baf5a…f5c0a967 (20 bytes)
0x20 e4 b6 65 00 file_size 6.665.956
0x24 70 00 00 00 header_size 112 = 0x70 → v040 o anterior
0x28 78 56 34 12 endian_tag 0x12345678 → little-endian
0x34 14 b6 65 00 map_off 6.665.748 = 0x65b614
0x38 / 0x3c 0b ac 00 00 / 70 00 00 00 string_ids_size / _off 44.043 / 112
0x40 / 0x44 6f 1f 00 00 / 9c b0 02 00 type_ids_size / _off 8.047 / 176.284
0x48 / 0x4c c7 23 00 00 / 58 2e 03 00 proto_ids_size / _off 9.159 / 208.472
0x50 / 0x54 db 5b 00 00 / ac db 04 00 field_ids_size / _off 23.515 / 318.380
0x58 / 0x5c b4 93 00 00 / 84 ba 07 00 method_ids_size / _off 37.812 / 506.500
0x60 / 0x64 38 19 00 00 / 24 58 0c 00 class_defs_size / _off 6.456 / 808.996
0x68 / 0x6c c0 37 56 00 / 24 7f 0f 00 data_size / data_off 5.650.368 / 1.015.588
0x70 d8 3e 4d 00 string_ids[0] string_data_off = 5.062.360

La herramienta oficial da lo mismo salvo endian_tag y map_off, que no imprime:

$BT/dexdump -f $DEXDIR/classes.dex | head -24
Processing '…/classes.dex'...
Opened '…/classes.dex', DEX version '035'
DEX file header:
magic               : 'dex\n035\0'
checksum            : 87484e50
signature           : 7f1b...a967
file_size           : 6665956
header_size         : 112
…
method_ids_size     : 37812
class_defs_size     : 6456
data_off            : 1015588 (0x0f7f24)

-f es «display dex file header»; -h es «display all sections header» y vuelca la cabecera de cada clase, que es otra cosa. (dexdump 37.0.0 escribe antes una línea Processing '…'....)

Si prefieres empezar por un DEX mínimo, S.N.A.K.E (versión 1000001, F-Droid) lleva un classes.dex de 5.404 bytes, versión 037, con 4 clases y 71 method_ids. Su checksum es 0xb72a647a, su signature empieza por a37ef0b3dfec0763 y su map_off vale 0x147c (5.244). Cabe entero en las 13 entradas de su map_list («sección 5 · map_list: la vía fiable de recorrer el fichero»).

4. magic y la tabla de versiones

ubyte[8] DEX_FILE_MAGIC = { 0x64 0x65 0x78 0x0a 0x30 0x33 0x39 0x00 } = "dex\n039\0"

El salto de línea (0x0a) y el nulo (0x00) están puestos para detectar corrupciones de transferencia en modo texto. Los tres dígitos decimales son la versión del formato y crecen monótonamente. Esta tabla se copia mal a menudo; está contrastada contra las notas de la especificación y contra el array kDexMagicVersions de AOSP.

Versión Se acepta desde Qué introdujo
009 Plataforma M3 (nov.–dic. de 2007) Formato preliminar, muy distinto del actual
013 Plataforma M5 (feb.–mar. de 2008) Formato preliminar
035 Línea base: casi todo lo anterior a 037 —
036 No existe Saltada por un fallo antiguo de Dalvik que la aceptaba y ejecutaba erróneamente
037 Android 7.0 Métodos default de interfaz y el ajuste de invoke-super para invocarlos
038 Android 8.0 invoke-polymorphic, invoke-custom, method_handle_item y call_site_id_item
039 Android 9.0 const-method-handle y const-method-type. En Android 10 se amplía con información de hidden API, solo para los DEX del boot class path
040 Android 11, aunque la especificación dice 10.0 Amplía los caracteres de SimpleName: espacio, U+00a0, U+2000…U+200a, U+202f
041 Ver nota Formato contenedor: varios DEX lógicos en un fichero físico, compartiendo datos

Nota sobre la 040. La especificación y el comentario de AOSP dicen «Android 10», pero el array kDexMagicVersions de android-10.0.0_r1 y de android-10.0.0_r47 solo lleva 035, 037, 038 y 039: un Android 10 rechaza dex\n040\0 con Unknown dex version. La 040 entra en android-11.0.0_r1.

Nota sobre la 041. Las dos fuentes oficiales parecen contradecirse, pero hablan de cosas distintas. La especificación publicada habla del soporte: dice que «es experimental en la release de Android 16 para probar el formato contenedor» y que «no debería usarse en código de producción». El comentario de AOSP en standard_dex_file.cc, // Dex version 041: Android "V" and beyond (aka Android 15), habla del cargador, y hasta se queda corto. Lo que acepta cada etiqueta, leído en el kDexMagicVersions de su standard_dex_file.cc:

Etiqueta de AOSP ¿041 en kDexMagicVersions?
android-14.0.0_r1 a android-14.0.0_r28 No
android-14.0.0_r29 a android-14.0.0_r37 Sí
android-14.0.0_r38 a android-14.0.0_r45 No
android-14.0.0_r50, android-14.0.0_r60 y android-14.0.0_r75 Sí
android-15.0.0_r1 Sí
android-16.0.0_r1 Sí
android-17.0.0_r1 Sí

En android-15.0.0_r1, android-16.0.0_r1 y android-17.0.0_r1 están además el recorrido de contenedores de dex_file_loader.cc y las comprobaciones de v41 de dex_file_verifier.cc. Que la 041 entre y salga según la etiqueta no es un paso atrás: las etiquetas salen de líneas de compilación distintas. En la tabla de compilaciones de AOSP, r29 a r37 son AP1A y r50, r60 y r75, AP2A; r1 a r28 son UP1A, UD1A y UQ1A, y r38 a r45, UD2A, solo para el Pixel 8a. Otra cuestión es lo que acepta un dispositivo concreto: ART es un módulo Mainline, y eso depende de su versión de ART, no solo de la de Android. La cadena de herramientas va con la especificación: D8 9.2.4-dev solo emite 041 si se fuerza con la propiedad -Dcom.android.tools.r8.dexContainerExperiment, y entonces avisa «Forcing container DEX for an API level not supporting it» con cualquier --min-api inferior a 36, porque su código fija en BAKLAVA —Android 16— el nivel mínimo del formato contenedor.

Qué versión emite D8 según --min-api. Lo medimos compilando la misma clase trivial con d8 de build-tools 37.0.0 (D8 9.2.4-dev) y leyendo el magic con dexdump -f:

min-api  1 21 23 → dex\n035\0      min-api 26 27             → dex\n038\0
min-api 24 25    → dex\n037\0      min-api 28 29 30 33 35 36 → dex\n039\0

Los cortes 24 / 26 / 28 coinciden exactamente con las versiones de la tabla. Pero D8 no emite 040 ni 041 ni con --min-api 36, salvo con la propiedad experimental de la nota anterior: elige la versión del magic por --min-api, con la 039 como tope, y no por la API contra la que se compila. Así que un APK moderno con un minSdk bajo lleva perfectamente un DEX 035, y el magic de un DEX de D8 acota el minSdk con el que se generó. Por eso una app actual que funcione en Android 6 lleva un DEX 035. Y al revés: un DEX de D8 con versión 038 se hizo para un minSdk de 26 o 27.

Lo comprobamos en el muestrario, y se cumple. Muchos DEX de D8 y de R8 (el compilador que además recorta y ofusca) llevan en sus cadenas un marcador que dice con qué min-api se generaron («sección 4.1 · Quién generó un DEX»). En esos DEX, la versión de la cabecera es la esperada en todos menos 3, de más de 11.500. Uno de los 3 es el classes5.dex de io.github.muntashirakon.AppManager (versión 451, F-Droid), con cabecera 035, min-api 24 y D8 4.0.48 (debería ser 037). La copia de IzzyOnDroid tiene el mismo caso, y también app.simple.inure (versión 10724), cuyo fichero es el mismo en F-Droid y en IzzyOnDroid: por fuente salen 4, pero como ficheros distintos son 3. No hemos investigado por qué.

La regla «el magic acota el minSdk» solo se puede comprobar en los DEX cuyo marcador lleva min-api, y no son todos: falta en uno de cada cinco de F-Droid y en más de la mitad de los del mercado chino. Tres ejemplos de F-Droid que sí lo llevan: Droid-ify 780 dice min-api 23 y su cabecera es 035; Termux 1022 y S.N.A.K.E 1000001 dicen min-api 24 y su cabecera es 037.

Contra el minSdk del manifiesto (la versión más alta de los DEX de cada app), F-Droid cumple la regla casi sin excepciones: solo 5 apps se salen de su tramo. En las más instaladas de Google Play, en cambio, los tramos se desordenan: con minSdk 28 o más, 159 apps tienen 039, pero 63 tienen 035.

Cuántos DEX hay de cada versión. El «muestrario» tiene 16.158 ficheros classes*.dex. La versión depende de dónde viene la app. Cada fila es una fuente por separado y cuenta DEX, no apps.

Fuente DEX 035 037 038 039
F-Droid 7.185 44 % 24 % 21 % 11 %
IzzyOnDroid 2.198 42 % 25 % 22 % 12 %
Google Play, las más instaladas 4.916 33 % 31 % 14 % 22 %
Google Play, sorteo 1.317 33 % 50 % 10 % 8 %
Mercado chino 890 77 % 19 % 3 % 1 %

La 035 sigue mandando, sobre todo en el mercado chino, donde son casi 8 de cada 10. En el sorteo de Google Play el más habitual es el 037, y la 039 se ve sobre todo en las apps más instaladas. Ni un 040 ni un 041 en los 16.158 DEX: tampoco hay ninguno con header_size 0x78, ni un contenedor 041. Las filas no se suman, porque un fichero que está en F-Droid y en IzzyOnDroid cuenta en las dos.

Contado por app (la versión más alta de sus DEX), casi la mitad de las de F-Droid son 035 y una de cada cuatro de las más instaladas de Google Play es 039. Una app puede mezclar versiones: pasa en unas pocas de Google Play y del mercado chino, y en ninguna de F-Droid ni de IzzyOnDroid. Un ejemplo es com.google.android.as (versión B.30.playstore), con DEX 035 y 039.

4.1 Quién generó un DEX

Casi todo DEX nuevo lleva una huella de la herramienta que lo hizo. D8 y R8 escriben en las cadenas del fichero un texto que empieza por ~~D8 o ~~R8, seguido de un pequeño JSON con la versión, el modo (release o debug) y el min-api. R8 añade también r8-mode y pg-map-id. Se ve con cualquier lector de cadenas, aquí sobre Droid-ify 780:

unzip -p $MUESTRARIO/fdroid/com.looker.droidify_780.apk classes.dex | strings | grep '~~'
~~R8{"backend":"dex","compilation-mode":"release","desugared-library-identifiers":["com.tools.android:desugar_jdk_libs_configuration:2.1.5"],"has-checksums":false,"min-api":23,"pg-map-id":"ae06e847c618fe2b529b0ff6b4af8904ca732891fa1c5a4bdf155504602ab775","r8-mode":"full","version":"9.4.14"}

El min-api 23 explica la versión 035 de la cabecera de ese mismo fichero («sección 4 · magic y la tabla de versiones»). En su segundo DEX (classes2.dex) hay además un ~~L8: es la biblioteca de desugaring («sección 15 · El límite de 65.536 referencias y multidex»), que no decide quién generó el DEX. En Termux 1022 el marcador dice min-api 24, r8-mode compatibility y versión 2.2.71. En S.N.A.K.E 1000001, min-api 24, r8-mode full y versión 8.6.17.

Si no hay marcador, quedan otras pistas. El orden de las secciones del map_list identifica al generador («sección 5.2 · El orden del map_list como huella»), y herramientas como APKiD ponen una etiqueta (r8, dx, dexlib 2.x). Un ejemplo sin marcador es el classes.dex de cn.cj.pe (versión 202608010, mercado chino), de 72,5 MB y 40 clases, con un protector Bangcle/SecNeo.

Quién generó el DEX, por fuente. La unidad es la app, y la herramienta es la de su marcador propio. Una app cuenta como R8 si algún marcador propio es de R8; si no, como D8 si lo es de D8; si no, «sin marcador» (hay quien los borra). ~~L8 y los marcadores de bibliotecas no deciden.

Fuente Apps con DEX R8 D8 Sin marcador
F-Droid 4.765 58 % 39 % 3 %
IzzyOnDroid 1.402 66 % 32 % 2 %
Google Play, las más instaladas 658 62 % 26 % 12 %
Google Play, sorteo 369 43 % 52 % 5 %
Mercado chino 100 28 % 5 % 67 %

Con APKiD, la etiqueta principal es r8 en tres de cada cuatro apps de F-Droid e IzzyOnDroid, en la mitad de las más instaladas de Google Play y en el 60 % del sorteo. En el mercado chino la más repetida es dexlib 2.x (58 de 98 apps). Las proporciones de R8 y D8 salen del marcador, no de APKiD. Los detalles de R8 están en «R8 y ProGuard → §9 · Cómo se detecta que una app pasó por R8».

Para repetir estas cifras: python3 -I scripts/muestrario/cifras/nucleo_codigo.py calcula el compilador de cada app, y python3 -I scripts/muestrario/cifras/dex_y_bytecode_1.py --salida <fichero.json> añade la versión del marcador, la de cada DEX y la más alta por app.

5. map_list: la vía fiable de recorrer el fichero

Es la lista de todo lo que contiene el fichero, en orden. Duplica parte de la cabecera a propósito: la cabecera dice dónde están seis tablas, el map_list dice dónde está cada sección, incluidas las que la cabecera no menciona. Es un uint size seguido de size map_item de 12 bytes: ushort type con el código TYPE_*, ushort unused, uint size con el número de elementos y uint offset desde el inicio del fichero. Reglas que lo hacen utilizable como índice maestro: un tipo aparece como mucho una vez, las entradas van ordenadas por offset y no se solapan.

Estructura Constante Valor Tamaño de cada elemento
header_item TYPE_HEADER_ITEM 0x0000 0x70
string_id_item TYPE_STRING_ID_ITEM 0x0001 0x04
type_id_item TYPE_TYPE_ID_ITEM 0x0002 0x04
proto_id_item TYPE_PROTO_ID_ITEM 0x0003 0x0c
field_id_item TYPE_FIELD_ID_ITEM 0x0004 0x08
method_id_item TYPE_METHOD_ID_ITEM 0x0005 0x08
class_def_item TYPE_CLASS_DEF_ITEM 0x0006 0x20
call_site_id_item TYPE_CALL_SITE_ID_ITEM 0x0007 0x04
method_handle_item TYPE_METHOD_HANDLE_ITEM 0x0008 0x08
map_list TYPE_MAP_LIST 0x1000 4 + (size * 12)
type_list TYPE_TYPE_LIST 0x1001 4 + (size * 2)
annotation_set_ref_list TYPE_ANNOTATION_SET_REF_LIST 0x1002 4 + (size * 4)
annotation_set_item TYPE_ANNOTATION_SET_ITEM 0x1003 4 + (size * 4)
class_data_item TYPE_CLASS_DATA_ITEM 0x2000 implícito: hay que analizarlo
code_item TYPE_CODE_ITEM 0x2001 implícito
string_data_item TYPE_STRING_DATA_ITEM 0x2002 implícito
debug_info_item TYPE_DEBUG_INFO_ITEM 0x2003 implícito
annotation_item TYPE_ANNOTATION_ITEM 0x2004 implícito
encoded_array_item TYPE_ENCODED_ARRAY_ITEM 0x2005 implícito
annotations_directory_item TYPE_ANNOTATIONS_DIRECTORY_ITEM 0x2006 implícito
hiddenapi_class_data_item TYPE_HIDDENAPI_CLASS_DATA_ITEM 0xF000 implícito

TYPE_HIDDENAPI_CLASS_DATA_ITEM solo aparece en los DEX del boot class path («sección 4 · magic y la tabla de versiones»): un parser de APK puede tratarlo como opaco. En los 16.158 DEX del muestrario no aparece ni una vez.

El 0x70 de TYPE_HEADER_ITEM queda obsoleto en v041, donde la cabecera mide 0x78. La especificación no lo ha llevado a esta tabla —en la página actualizada el 3 de octubre de 2025, y todavía en la del 9 de octubre de 2026, la fila de header_item sigue diciendo 0x70—, aunque la descripción de header_size sí exige «0x78 (120) bytes (v41 or later)». D8 sigue la descripción: forzado a v041 con -Dcom.android.tools.r8.dexContainerExperiment, escribe header_size = 0x78 en cada cabecera lógica y apunta la entrada TYPE_HEADER_ITEM del map_list al offset de esa cabecera dentro del contenedor, que es lo que exige dex_file_verifier.cc (líneas 635-650 y 2510-2521 en android-17.0.0_r1), y no a 0. dexdump 37.0.0, que verifica al abrir, acepta el resultado. Nada de esto se ve en un fichero real: ningún DEX del muestrario tiene header_size distinto de 0x70 (0 de 16.158), así que no hay ninguno 041.

Por qué es la vía fiable. Quien recorre el fichero por la cabecera tiene que adivinar dónde empieza y acaba cada estructura de data, y no ve call_site_ids ni method_handles. Quien recorre el map_list obtiene el inventario completo, con garantía de orden y no solapamiento, detecta de inmediato huecos y solapes que delatan manipulación, y puede saltarse lo que no entiende usando el offset de la entrada siguiente.

Esto es el map_list del classes.dex de Droid-ify 780, decodificado en el orden real del fichero. Se obtiene con python3 -I scripts/muestrario/cifras/dex_y_bytecode_1.py --mapa <classes.dex> (dexdump no imprime el map_list):

map_off = 0x65b614   entradas = 17
 0x0000 HEADER_ITEM     1      0x000000    0x2003 DEBUG_INFO_ITEM     1190  0x4b6aa8
 0x0001 STRING_ID_ITEM  44043  0x000070    0x1001 TYPE_LIST           6550  0x4c25b0
 0x0002 TYPE_ID_ITEM    8047   0x02b09c    0x2002 STRING_DATA_ITEM   44043  0x4d3ed8
 0x0003 PROTO_ID_ITEM   9159   0x032e58    0x2004 ANNOTATION_ITEM      163  0x611d4a
 0x0004 FIELD_ID_ITEM   23515  0x04dbac    0x2000 CLASS_DATA_ITEM     6034  0x6127d4
 0x0005 METHOD_ID_ITEM  37812  0x07ba84    0x2005 ENCODED_ARRAY         20  0x659ec2
 0x0006 CLASS_DEF_ITEM  6456   0x0c5824    0x1003 ANNOTATION_SET       151  0x659fec
 0x2001 CODE_ITEM       30460  0x0f7f24    0x2006 ANNOT_DIRECTORY      178  0x65a504
                                           0x1000 MAP_LIST               1  0x65b614
 (tipo, nº de elementos, offset — en el orden real del fichero)

Se cierra solo: 0x65b614 + 4 + 17 × 12 = 6.665.956 = file_size. Y el orden de tipos no es el numérico: TYPE_CODE_ITEM (0x2001) va antes que TYPE_TYPE_LIST (0x1001). Ordenar por código TYPE_* en vez de por offset es un error fácil de cometer y difícil de detectar.

Cerrar así es lo normal, no una regla: lo hacen más del 99 % de los DEX, algo menos en el mercado chino. Los pocos que no cierran (160) tienen el map_list antes del final, como los de dx («sección 5.2 · El orden del map_list como huella»), o bytes detrás de los datos, como los de algunos protectores («sección 17.2 · Protectores: el DEX visible es una cáscara»).

El orden de las secciones depende del generador. Los DEX de D8 y R8 ponen TYPE_CODE_ITEM antes que TYPE_TYPE_LIST. Los de otras herramientas, como dexlib, lo hacen al revés. En F-Droid e IzzyOnDroid casi todos siguen el orden de D8; en el mercado chino, solo algo más de la mitad. Los que ponen primero type_list son sobre todo DEX que APKiD etiqueta como dexlib 2.x (1.168 de 1.243). Esa etiqueta usa a su vez el orden del map_list, así que el cruce no es una prueba independiente («sección 5.2 · El orden del map_list como huella»). Un ejemplo es el classes.dex de la pieza split_df_player_optional.apk de com.zhiliaoapp.musically (TikTok, versión 47.4.16), con el orden «H S T P M C SD TL DI CI CD ML».

Un DEX sin campos declarados simplemente no lleva entrada FIELD_ID_ITEM: la ausencia de un tipo es legítima y significa cero elementos. No es raro: 499 DEX del muestrario no tienen ningún campo, y ninguno trae una entrada con tamaño 0. Un ejemplo es el classes2.dex de Termux 1022, de 876 bytes, que define una sola clase (j$/util/DesugarTimeZone) con 4 métodos:

  0x0000 HEADER_ITEM      1  0x000000      0x2001 CODE_ITEM        2  0x000108
  0x0001 STRING_ID_ITEM  11  0x000070      0x1001 TYPE_LIST        1  0x00013c
  0x0002 TYPE_ID_ITEM     5  0x00009c      0x2002 STRING_DATA_ITEM 11 0x000142
  0x0003 PROTO_ID_ITEM    2  0x0000b0      0x2000 CLASS_DATA_ITEM  1  0x0002d5
  0x0005 METHOD_ID_ITEM   4  0x0000c8      0x1000 MAP_LIST         1  0x0002e4
  0x0006 CLASS_DEF_ITEM   1  0x0000e8

Falta 0x0004 (FIELD_ID_ITEM) y tampoco hay debug_info_item. El mapa tiene 11 entradas y cierra: 0x2e4 + 4 + 11 × 12 = 876.

5.1 Cómo recorrer un contenedor 041

Un fichero 041 es, según la especificación, «mostly just naive concatenation» de DEX lógicos, cada uno con su propia cabecera de 0x78 bytes. Ningún DEX del muestrario es un contenedor 041 (0 de 16.158): esta sección describe la especificación y el código de ART, el motor que ejecuta las apps, no ficheros reales. Se recorre así:

  1. La primera cabecera está en el offset 0.
  2. Su file_size no es el tamaño del fichero, sino la distancia hasta la cabecera siguiente: la próxima está en header_offset + file_size.
  3. Se sigue mientras header_offset + file_size sea menor que container_size; el último DEX lógico es el que acaba justo ahí.
  4. Cada cabecera lleva su propia posición en header_offset y el tamaño del fichero entero en container_size. data_size y data_off ya no se usan.
  5. Todos los offsets —los de la cabecera, los del map_list y los de dentro de data— cuentan desde el inicio del contenedor, nunca desde la cabecera: «All offsets are relative to the physical file». Un DEX lógico puede apuntar a datos que vayan detrás, en otro DEX lógico, pero no a datos anteriores, y así comparten cadenas.

ART lo hace igual. DexFileLoader abre el DEX del offset 0, suma su file_size para dar con la cabecera siguiente y para cuando el DEX lógico acaba donde acaba el contenedor (dex_file_loader.cc, líneas 440-465), y resuelve cada offset contra el inicio del contenedor, que obtiene restando header_offset a la dirección de la cabecera (dex_file.cc, líneas 247-265). El checksum de cada uno cubre solo su tramo («sección 14 · Checksums: qué recalcular y en qué orden»). Y dex_file_verifier.cc exige a cada cabecera de un 041:

Condición Mensaje Líneas
header_size = 0x78 Bad header size: %ud expected %zud 635-650
container_size mayor que header_offset Dex container is too small: size=%ud header_offset=%ud 673-679
container_size no mayor que el fichero real Claimed container size (%ud) exceeds actual container size (%zu) 681-688
file_size dentro de lo que queda de contenedor desde header_offset Header file_size(%ud) is past multi-dex size(%ud) 690-696
Ningún offset de la cabecera antes de la propia cabecera ni fuera del contenedor Offset(%d) should be after header(%zu) for %s. y Offset(%d) should be within file size(%zu) for %s. 593-600
La entrada TYPE_HEADER_ITEM del map_list en header_offset, no en 0 Header at %x, expected %x 2510-2518

5.2 El orden del map_list como huella

Cada herramienta que escribe DEX coloca las secciones de datos en un orden propio. Si falta el marcador ~~D8/~~R8 («sección 4.1 · Quién generó un DEX»), el orden ayuda a saber quién generó el fichero. Aquí comparamos solo las secciones de datos: code_item (CI), debug_info_item (DI), type_list (TL), string_data_item (SD), class_data_item (CD) y map_list (ML). Así un DEX sin campos conserva la misma huella que los demás de su herramienta. Los recuentos son de DEX distintos.

  • Con marcador R8 (8.214 DEX): «CI DI TL SD CD ML» en 7.931. Es el orden de Droid-ify 780, cuyo map_list completo es H S T P F M C CI DI TL SD AI CD EA AS AD ML.
  • Con marcador D8 (3.105 DEX): el mismo orden en 2.735, y «CI TL SD CD ML», sin debug_info_item, en 287.
  • Sin marcador (4.826 DEX): «CI DI TL SD CD ML» en 3.105, «SD TL DI CI CD ML» en 1.255, «TL SD CI CD DI ML» en 154 y «ML TL CD CI SD DI» en 118.
  • Según APKiD (solo DEX de las apps que midió enteras): «SD TL DI CI CD ML» es de dexlib 2.x en 1.168 DEX y queda sin etiqueta en 75. «ML TL CD CI SD DI», con el map_list justo tras las class_defs, es de dx (possible dexmerge) en 118 DEX y de r8 (possible dexmerge) en 8.

dexlib es la biblioteca en la que se apoyan smali y baksmali. dx y dexmerge son herramientas anteriores a D8. La atribución a dexlib y a dx es la de APKiD, que usa este mismo orden como pista: no es una prueba independiente. Un ejemplo con otra huella es el classes.dex de cn.cj.pe (versión 202608010, mercado chino), un DEX de Bangcle/SecNeo con 17 entradas en el orden «H S T P F M C SD TL AI…».

6. Las tablas de índices

Ninguna guarda texto: todas terminan apuntando a string_ids. Salvo method_handles, todas están ordenadas y sin duplicados, lo que permite bisección y hace que renombrar un identificador desplace media tabla.

Estructura Campo Offset Tamaño Tipo Significado
string_id_item string_data_off 0x00 4 uint Offset del string_data_item. Sin requisito de alineación
type_id_item descriptor_idx 0x00 4 uint Índice en string_ids del TypeDescriptor
proto_id_item shorty_idx 0x00 4 uint Índice en string_ids del ShortyDescriptor
return_type_idx 0x04 4 uint Índice en type_ids del tipo de retorno
parameters_off 0x08 4 uint Offset a un type_list de parámetros, o 0. No puede contener void
field_id_item class_idx 0x00 2 ushort Índice en type_ids del definidor. Debe ser una clase
type_idx 0x02 2 ushort Índice en type_ids del tipo del campo
name_idx 0x04 4 uint Índice en string_ids del nombre
method_id_item class_idx 0x00 2 ushort Índice en type_ids. Clase o array, no primitivo
proto_idx 0x02 2 ushort Índice en proto_ids
name_idx 0x04 4 uint Índice en string_ids del nombre
call_site_id_item call_site_off 0x00 4 uint Offset a un call_site_item, que es un encoded_array_item
method_handle_item method_handle_type 0x00 2 ushort STATIC_PUT 0x00, STATIC_GET 0x01, INSTANCE_PUT 0x02, INSTANCE_GET 0x03, INVOKE_STATIC 0x04, INVOKE_INSTANCE 0x05, INVOKE_CONSTRUCTOR 0x06, INVOKE_DIRECT 0x07, INVOKE_INTERFACE 0x08
unused 0x02 2 ushort Sin usar
field_or_method_id 0x04 2 ushort Índice en field_ids o en method_ids, según el tipo
unused 0x06 2 ushort Sin usar

Criterios de ordenación: string_ids por contenido de la cadena, comparando valores de code point UTF-16 y sin sensibilidad al locale; type_ids por índice en string_ids; proto_ids por tipo de retorno y luego por lista de argumentos en orden lexicográfico; field_ids y method_ids por definidor, luego nombre, luego tipo o prototipo; class_defs de modo que superclase e interfaces aparezcan antes que la clase que las usa; call_site_ids de forma ascendente por call_site_off. method_handles no está ordenado y admite duplicados, que corresponden a instancias distintas de method handle.

NO_INDEX = 0xffffffff marca la ausencia de índice. No vale 0 porque 0 suele ser un índice válido, y está elegido para que quepa en un solo byte codificado como uleb128p1.

Un call_site_item es un encoded_array_item cuyos tres primeros elementos son siempre el method handle del bootstrap linker (VALUE_METHOD_HANDLE), el nombre del método a resolver (VALUE_STRING) y su tipo (VALUE_METHOD_TYPE); lo que sigue son constantes que se pasan al bootstrap, que debe devolver java.lang.invoke.CallSite y recibir como tres primeros parámetros java.lang.invoke.Lookup, java.lang.String y java.lang.invoke.MethodType. Un volcado real de estas dos tablas, con la instrucción invoke-custom que las consume, está en «Bytecode Dalvik → §7.2 · invoke-polymorphic e invoke-custom».

Estas dos tablas casi no se ven en DEX reales. Los compiladores de hoy (D8, R8) no emiten invoke-custom para las lambdas: crean una clase $$ExternalSyntheticLambda por cada una, y eso lo ves en más de un tercio de las apps de F-Droid y en la mitad de las más instaladas de Google Play. En cambio, de los 16.158 DEX del muestrario solo uno tiene call_site_ids: el de com.droidheat.musicplayer (versión 35, IzzyOnDroid), con 24 sitios de llamada y 23 method_handle_item, cabecera 038 y D8 1.4.

class_idxdescriptor_idxsuperclass_idx(o NO_INDEX si esjava.lang.Object)interfaces_offtype_idxsource_file_idx(o NO_INDEX)annotations_offstatic_values_offclass_data_offfield_idx_diffclass_idxtype_idxname_idxmethod_idx_diffclass_idxproto_idxname_idxcode_offdebug_info_offclass_def_itemtype_idsstring_idstype_idstype_listtype_idsstring_idsannotations_directory_itemencoded_array_itemclass_data_itemencoded_field[]field_idstype_idstype_idsstring_idsencoded_method[]method_idstype_idsproto_idsstring_idscode_item…

7. Descriptores de tipo y shorty

Sintaxis Significado Sintaxis Significado
V void, solo como retorno J long
Z boolean F float
B byte D double
S short Lnombre/completo/Clase; La clase nombre.completo.Clase
C char [descriptor Array, recursivo. Máximo 255 dimensiones
I int

El punto del paquete se escribe con barra: Ljava/lang/String;. Un array bidimensional de enteros es [[I; uno de cadenas, [Ljava/lang/String;.

Los nombres admisibles los fija la gramática de SimpleName, mucho más permisiva que la de Java: además de letras, dígitos, $, - y _, admite casi todos los code points no ASCII que no sean de control ni especiales, y desde la versión 040 también el espacio. Eso dice la especificación; el verificador de AOSP no mira la versión al validar el nombre (IsValidMemberName, en descriptors_names.cc) y, desde android-11.0.0_r1, acepta el espacio incluso en un DEX 035. Eso es lo que explotan algunos ofuscadores: generan nombres hechos solo con O, 0 y o, o con letras no ASCII, que un decompilador a Java no puede escribir como código válido; ver «Ofuscadores comerciales».

En el muestrario aparece, pero poco. Llamamos «paquete de diccionario» a un componente de nombre de 3 o más caracteres formado solo por I, l y 1, o solo por O, 0 y o, o con caracteres no ASCII, entre los 40 paquetes más poblados de un DEX. Solo lo hemos visto en Google Play (12 de 658 apps) y en el mercado chino (8 de 100). Dos casos extremos: la pieza base.apk de CamScanner (com.intsig.camscanner, versión 7.27.0.2609220000) tiene 254.438 identificadores no ASCII, y Zepp Life (com.xiaomi.hm.health, versión 50847, mercado chino) tiene 1.814.613 de 2.236.902 identificadores hechos solo con O, 0 y o (81,1 %). No hemos medido cuántos nombres llevan espacios, palabras reservadas de Java o caracteres inválidos en un identificador de Java.

Un shorty es la forma corta de un prototipo: tipo de retorno seguido de los tipos de los parámetros, colapsando toda referencia en una única L, sin paréntesis ni punto y coma. El runtime lo usa para decidir el paso de argumentos sin resolver los tipos.

Firma Java Prototipo shorty
void f() ()V V
int f(int, int) (II)I III
String f(String, int) (Ljava/lang/String;I)Ljava/lang/String; LLI
long[] f(double) (D)[J LD

La última fila es la reveladora: [J es una referencia, así que en el shorty es L.

8. Codificaciones

8.1 LEB128

LEB128 («Little-Endian Base 128») viene de DWARF3. En un DEX solo codifica cantidades de 32 bits, así que un valor ocupa de uno a cinco bytes. Cada byte lleva su bit más significativo a 1 salvo el último, que lo lleva a 0; los otros siete son carga útil, con los siete menos significativos del valor en el primer byte.

 byte 0                          byte 1
┌───┬───┬───┬───┬───┬───┬───┬───┐┌───┬────┬────┬────┬────┬───┬───┬───┐
│ 1 │b6 │b5 │b4 │b3 │b2 │b1 │b0 ││ 0 │b13 │b12 │b11 │b10 │b9 │b8 │b7 │
└───┴───┴───┴───┴───┴───┴───┴───┘└───┴────┴────┴────┴────┴───┴───┴───┘
  ↑ hay continuación                ↑ último byte

uleb128 interpreta como 0 los bits no representados. sleb128 extiende con signo el bit de carga más significativo del último byte. uleb128p1 codifica el valor más uno como uleb128: sirve donde el número debe ser no negativo o exactamente -1 (el NO_INDEX), y hace que ese -1 —y solo ese negativo— quepa en un byte.

Secuencia Como sleb128 Como uleb128 Como uleb128p1
00 0 0 −1
01 1 1 0
7f −1 127 126
80 7f −128 16.256 16.255

Veamos el caso 80 7f paso a paso. 0x80 = 1000 0000: bit alto a 1, hay continuación, carga 000 0000 = 0. 0x7f = 0111 1111: bit alto a 0, es el último, carga 111 1111 = 127. De ahí uleb128 = 0 | (127 << 7) = 16.256, uleb128p1 = 16.255, y sleb128 = −128 porque el bit más significativo de la carga del último byte vale 1 y se extiende con signo.

Un caso real, del encoded_type_addr_pair de la «sección 11 · code_item», donde 87 16 codifica un type_idx: 0x87 = 1000 0111 continúa con carga 7; 0x16 = 0001 0110 es el último con carga 22; valor = 7 | (22 << 7) = 2.823, que dexdump resuelve como Ljava/io/IOException;. Está en el classes.dex de Termux 1022, en el offset 0x0e48f2. Para comprobar qué tipo es el 2.823: python3 -I scripts/muestrario/cifras/dex_y_bytecode_1.py --tipo <classes.dex> 2823.

El error clásico al implementar es no acotar la longitud. Un uleb128 legítimo nunca pasa de cinco bytes; un fichero manipulado puede traer una secuencia infinita de bytes con el bit alto puesto y colgar a un lector ingenuo.

8.2 MUTF-8

Las cadenas del DEX no están en UTF-8, sino en MUTF-8 (Modified UTF-8), que difiere del estándar en cuatro puntos, los cuatro con consecuencias:

  1. Solo se usan las formas de uno, dos y tres bytes. Nunca cuatro.
  2. Los code points U+10000–U+10ffff se codifican como par subrogado, cada mitad con su forma de tres bytes: seis bytes donde UTF-8 usaría cuatro.
  3. El code point U+0000 se codifica en dos bytes (c0 80), no en uno.
  4. Un byte nulo suelto marca el final de la cadena, como en C.

Los dos primeros se resumen en que MUTF-8 es una codificación de UTF-16, no de Unicode; los dos últimos permiten a la vez incluir U+0000 dentro de una cadena y seguir tratándola como cadena terminada en nulo. Formalmente está más cerca de CESU-8.

Lo comprobamos compilando con d8 una clase con tres constantes —"a\0b", "😀" (U+1F600) y "ñ" (U+00F1)— y volcando los string_data_item. El primer byte es el utf16_size en uleb128; el último, el terminador:

idx  9  off=0x0178  utf16_size=3    bytes= 03 61 c0 80 62 00
idx 11  off=0x021d  utf16_size=1    bytes= 01 c3 b1 00
idx 12  off=0x0221  utf16_size=2    bytes= 02 ed a0 bd ed b8 80 00
  • "a\0b" → 61 (a), c0 80 (el nulo en dos bytes), 62 (b), 00 (fin). En UTF-8 estándar el nulo sería un solo 00 y la cadena se habría cortado tras la a.
  • "ñ" → c3 b1, idéntico a UTF-8: por debajo de U+0800 no hay diferencia.
  • "😀" → ed a0 bd (U+D83D) + ed b8 80 (U+DE00), el par subrogado. UTF-8 estándar habría emitido f0 9f 98 80, cuatro bytes.

Y el detalle que rompe más implementaciones: utf16_size cuenta unidades de código UTF-16, no bytes ni caracteres. El emoji vale 2; "a\0b" vale 3 aunque ocupe 4 bytes.

Qué se rompe al confundirlos: un decodificador UTF-8 estricto falla ante c0 80 y ante las subrogadas, que son secuencias inválidas en UTF-8 (String::from_utf8 en Rust devuelve error; bytes.decode('utf-8') en Python lanza UnicodeDecodeError); uno permisivo produce U+FFFD y pierde el contenido en silencio, que es peor; reservar utf16_size bytes provoca lecturas cortas en cuanto hay un carácter no ASCII; y strcmp sobre MUTF-8 no da el orden correcto en presencia de U+0000, cosa que la especificación advierte de forma explícita. Además se admiten cadenas con subrogadas sueltas o desordenadas: rechazarlas es responsabilidad de la capa superior.

9. La sección de datos

string_data_item (sin alineación): uleb128 utf16_size con la longitud decodificada en unidades UTF-16, seguido de las unidades MUTF-8 y un byte 0. La longitud codificada está implícita en la posición de ese nulo; los dos datos son redundantes a propósito y pueden discrepar en un fichero manipulado.

type_list (alineación 4): uint size y size type_item, cada uno un ushort con un índice en type_ids. Lo usan class_def_item.interfaces_off y proto_id_item.parameters_off.

encoded_value: el primer byte lleva el tipo en los cinco bits bajos y un argumento en los tres altos, (value_arg << 5) | value_type. En casi todos los casos value_arg es tamaño − 1 del valor que sigue: 0 significa un byte, 7 significa ocho.

Tipo value_type value_arg Formato del valor
VALUE_BYTE 0x00 0 ubyte[1]
VALUE_SHORT / VALUE_CHAR 0x02 / 0x03 tamaño−1 Entero de 2 bytes, extendido con signo / con ceros
VALUE_INT / VALUE_LONG 0x04 / 0x06 tamaño−1 Entero con signo, extendido con signo
VALUE_FLOAT / VALUE_DOUBLE 0x10 / 0x11 tamaño−1 IEEE754, extendido con ceros a la derecha
Índices: VALUE_METHOD_TYPE 0x15 → proto_ids; VALUE_METHOD_HANDLE 0x16 → method_handles; VALUE_STRING 0x17 → string_ids; VALUE_TYPE 0x18 → type_ids; VALUE_FIELD 0x19 y VALUE_ENUM 0x1b → field_ids; VALUE_METHOD 0x1a → method_ids tamaño−1 (0…3) Entero sin signo, extendido con ceros
VALUE_ARRAY / VALUE_ANNOTATION 0x1c / 0x1d 0 encoded_array / encoded_annotation; el tamaño va implícito
VALUE_NULL 0x1e 0 Ninguno
VALUE_BOOLEAN 0x1f el valor (0…1) Ninguno: el bit viaja en value_arg

Dos trampas: el «extendido con ceros a la derecha» de los flotantes —un float 2.0 (0x40000000) cabe en un byte, y un 1.0 (0x3F800000) en dos: d8 emite 30 80 3f— y el VALUE_BOOLEAN, sin payload. Un encoded_array es un uleb128 con el número de elementos seguido de esos elementos concatenados; el encoded_array_item de la sección data no es más que eso, y es lo que apunta class_def_item.static_values_off.

Anotaciones. El annotations_directory_item (alineación 4) lleva class_annotations_off, los contadores fields_size, annotated_methods_size y annotated_parameters_size, y las tres listas correspondientes: field_annotations (field_idx + annotations_off), method_annotations (method_idx + annotations_off) y parameter_annotations (method_idx + offset a un annotation_set_ref_list). Las tres van ordenadas de forma ascendente por su índice y todos los field_id/method_id deben referirse a la misma clase definidora. Un annotation_set_item (alineación 4) es un uint size y size offsets a annotation_item, ordenados por type_idx; un annotation_item (sin alineación) es un ubyte visibility más un encoded_annotation.

Constante Valor Significado Equivalente Java
VISIBILITY_BUILD 0x00 Solo visible en tiempo de compilación @Retention(CLASS)
VISIBILITY_RUNTIME 0x01 Visible en ejecución @Retention(RUNTIME)
VISIBILITY_SYSTEM 0x02 Visible en ejecución, pero solo para el sistema —

VISIBILITY_SYSTEM es el que usan las anotaciones de sistema, donde el DEX guarda lo que en un .class iría en atributos propios: dalvik.annotation.Signature (los genéricos, como array de cadenas a concatenar), Throws, InnerClass, EnclosingClass, EnclosingMethod, MemberClasses, MethodParameters y AnnotationDefault. Para quien decompila esto importa: los genéricos sobreviven en dalvik.annotation.Signature, no en la firma del método, y si el ofuscador los elimina —R8 lo hace salvo que se le pida -keepattributes Signature y, en full mode, además una keep rule que case la clase o el miembro— ya no se puede reconstruir List<String>, solo List. Ver la «sección 8 de R8 y ProGuard · R8 full mode».

Lo vemos en DEX reales, con un ejemplo por caso (no son cifras de población). Contamos los annotation_item del map_list (tipo 0x2004), sin ejecutar nada, agrupados por el tipo de su anotación. El classes.dex de Droid-ify 780 (R8 9.4.14, modo full) conserva 118 anotaciones Signature entre sus 163 annotation_item, en 6.456 clases. El de Termux 1022 (R8 2.2.71, modo compatibility) conserva 1.573 de sus 4.479 annotation_item, en 2.742 clases. El de S.N.A.K.E 1000001 (R8 8.6.17, modo full) no tiene ninguna anotación. Donde no queda Signature, un decompilador ve List y no List<String>.

Kotlin en el DEX. Muchas apps modernas incluyen código Kotlin. Su rastro en el DEX es la anotación kotlin.Metadata, que guarda la información de Kotlin que no cabe en el bytecode (por ejemplo, firmas con tipos que aceptan null). Aparece en alguna clase de un tercio de las apps de F-Droid e IzzyOnDroid, dos de cada tres de las de Google Play y la mitad de las del mercado chino. Es un mínimo de las apps con Kotlin, porque R8 puede eliminar la anotación.

9.1 encoded_annotation y annotation_set_ref_list

Las dos estructuras de anotaciones que el resto de la sección nombra sin desarrollar. El encoded_annotation va en línea en dos sitios: dentro de cada annotation_item, detrás del byte visibility, y como valor VALUE_ANNOTATION de un encoded_value, que es como una anotación lleva otra dentro. El annotation_set_ref_list es lo que apunta cada entrada de parameter_annotations: las anotaciones de los parámetros de un método.

Estructura Campo Tipo Significado
encoded_annotation type_idx uleb128 Índice en type_ids del tipo de la anotación. Debe ser una clase, no un array ni un primitivo
size uleb128 Número de pares nombre-valor
elements annotation_element[size] Los pares, en línea y no por offset, ordenados de forma ascendente por su índice en string_ids
annotation_element name_idx uleb128 Índice en string_ids del nombre del elemento, con la sintaxis de MemberName
value encoded_value El valor del elemento
annotation_set_ref_list (alineación 4) size uint Número de entradas de la lista
list annotation_set_ref_item[size] Las entradas
annotation_set_ref_item annotations_off uint Offset desde el inicio del fichero al annotation_set_item referenciado, o 0 si ese elemento no tiene anotaciones

10. class_def_item y class_data_item

class_def_item: 32 bytes, alineación 4.

Campo Offset Tamaño Tipo Significado
class_idx 0x00 4 uint Índice en type_ids de esta clase. Debe ser una clase
access_flags 0x04 4 uint Ver «sección 13 · access_flags»
superclass_idx 0x08 4 uint Índice en type_ids de la superclase, o NO_INDEX si es raíz
interfaces_off 0x0c 4 uint Offset a un type_list con las interfaces, o 0. Sin duplicados
source_file_idx 0x10 4 uint Índice en string_ids del fichero fuente, o NO_INDEX
annotations_off 0x14 4 uint Offset a annotations_directory_item, o 0
class_data_off 0x18 4 uint Offset a class_data_item, o 0 (p. ej. una interfaz marcadora)
static_values_off 0x1c 4 uint Offset a encoded_array_item con los valores iniciales de los campos estáticos, o 0

El array de static_values_off puede ser más corto que el número de campos estáticos: los que sobran se inicializan al cero o al null de su tipo. Truncarlo es una optimización legítima que un lector debe tolerar, y no es teoría: en el classes.dex de Droid-ify 780, 9 de las 22 clases que traen valores iniciales los traen truncados, y en el de Termux 1022, 10 de 97. Son recuentos de un DEX por ejemplo, comparando static_fields_size del class_data_item con el tamaño del encoded_array_item. No hay cifra de población.

class_data_item (sin alineación, todo uleb128) lleva primero los cuatro tamaños —static_fields_size, instance_fields_size, direct_methods_size, virtual_methods_size— y después las cuatro listas en ese mismo orden. Los métodos directos son los estáticos, privados y constructores; los virtuales, ninguna de esas tres cosas, y la lista no incluye los heredados salvo que la clase los sobrescriba.

Elemento Campo Tipo Significado
encoded_field field_idx_diff uleb128 Diferencia respecto al índice del elemento anterior
access_flags uleb128 Ver «sección 13 · access_flags»
encoded_method method_idx_diff uleb128 Diferencia respecto al anterior
access_flags uleb128
code_off uleb128 Offset al code_item, o 0 si el método es abstract o native

La codificación delta es donde se equivocan los parsers. Los índices no son absolutos, son incrementos: el primer elemento de cada una de las cuatro listas lleva su índice directamente; cada siguiente lleva la diferencia respecto al anterior de su propia lista; y el acumulador se reinicia en cada lista, de modo que instance_fields no continúa desde donde acabó static_fields, ni virtual_methods desde direct_methods.

Los cuatro errores típicos, por frecuencia: llevar un solo acumulador para las cuatro listas; llevar uno para los campos y otro para los métodos —el más sutil, porque produce salidas plausibles—; tratar el primer elemento como delta sobre cero cuando su lista está vacía y la siguiente no; e interpretar el delta como con signo, cuando es uleb128 y las listas van en orden creciente, así que nunca es negativo.

En principio no hay repeticiones, y un delta de 0 solo aparece en el primer elemento de una lista cuyo índice es 0. Pero ART no rechaza las repeticiones: DexFileVerifier::CheckOrder solo falla si el índice retrocede, y class_linker.cc las acepta a propósito —«We allow duplicate definitions of the same field in a class_data_item but ignore the repeated indexes here, b/21868015»—. Un parser que quiera leer lo mismo que Android tiene que aceptar el delta 0 y quedarse con la primera definición; lo que es corrupción es un índice que retrocede. En la práctica no lo hemos visto: en tres DEX reales (el classes.dex y el classes2.dex de Droid-ify 780 y el classes.dex de Termux 1022) no aparece ni un delta 0 fuera del primer elemento de cada lista, entre casi 90.000 elementos. Tampoco aquí hay recuento de población.

11. code_item

Alineación 4 bytes. Es el cuerpo de un método.

Campo Offset Tamaño Tipo Significado
registers_size 0x00 2 ushort Número total de registros del marco
ins_size 0x02 2 ushort Número de palabras de argumentos de entrada
outs_size 0x04 2 ushort Palabras de argumentos de salida que necesita para invocar
tries_size 0x06 2 ushort Número de try_item
debug_info_off 0x08 4 uint Offset al debug_info_item, o 0 si no hay información de depuración
insns_size 0x0c 4 uint Tamaño del bytecode en unidades de 16 bits, no en bytes
insns 0x10 2×insns_size ushort[] El bytecode («Bytecode Dalvik»)
padding — 0 o 2 ushort = 0 Solo si tries_size != 0 y insns_size es impar
tries — 8×tries_size try_item[] Solo si tries_size != 0
handlers — var encoded_catch_handler_list Solo si tries_size != 0

Los tres números de registros se explican en «Bytecode Dalvik → §3 · Modelo de registros»: registers_size es el total, los últimos ins_size registros contienen los argumentos (incluido el this implícito) y outs_size es el ancho del mayor invoke-* del cuerpo.

Sobre alineación hay dos reglas distintas que se confunden. El campo padding es el que alinea tries a 4 bytes y solo existe si hay tries y el bytecode ocupa un número impar de unidades. Aparte de eso, cada code_item empieza en múltiplo de 4, lo que obliga a rellenar entre un code_item y el siguiente aunque no haya tries; ese relleno no es un campo de la estructura y no aparece en la tabla.

try_item mide 8 bytes: uint start_addr (inicio del bloque cubierto, en unidades de 16 bits), ushort insn_count (unidades cubiertas; la última incluida es start_addr + insn_count − 1) y ushort handler_off (offset en bytes desde el inicio del encoded_catch_handler_list). Los try_item no se solapan y van de dirección baja a alta; handler_off es un offset de bytes, no un índice, precisamente para que varios try_item puedan compartir handler apuntando al mismo sitio.

El encoded_catch_handler_list es un uleb128 size seguido de esos encoded_catch_handler concatenados. Cada uno lleva un sleb128 size, luego abs(size) pares encoded_type_addr_pair (uleb128 type_idx + uleb128 addr) y, solo si size no es positivo, un uleb128 catch_all_addr. El signo es la trampa: 0 significa «hay catch-all y ningún tipo explícito», 2 significa «dos tipos y ningún catch-all» y −1 significa «un tipo y además catch-all». Quien use uleb128 en vez de sleb128 decodifica ese −1 como un número enorme y se pierde.

11.1 Un code_item con try/catch, byte a byte

El método es androidx.core.graphics.TypefaceCompatUtil.closeQuietly:(Ljava/io/Closeable;)V, en Termux 1022 (F-Droid), dentro de su classes.dex de 3.203.456 bytes. Esto es lo que dice dexdump -d:

0e48cc:                                        |[0e48cc] androidx.core.graphics.TypefaceCompatUtil.closeQuietly:(Ljava/io/Closeable;)V
0e48dc: 3800 0500                              |0000: if-eqz v0, 0005 // +0005
0e48e0: 7210 e850 0000                         |0002: invoke-interface {v0}, Ljava/io/Closeable;.close:()V // method@50e8
0e48e6: 0e00                                   |0005: return-void
      catches       : 1
        0x0002 - 0x0005
          Ljava/io/IOException; -> 0x0005

Y los bytes, con xxd -s $((0x0e48cc)) -l 48:

000e48cc: 0100 0100 0100 0100 2b70 1e00 0600 0000  ........+p......
000e48dc: 3800 0500 7210 e850 0000 0e00 0200 0000  8...r..P........
000e48ec: 0300 0100 0101 8716 0500 0000 0500 0300  ................
Offset Bytes Interpretación
0x0e48cc 0100 0100 0100 0100 registers_size = 1, ins_size = 1, outs_size = 1, tries_size = 1
0x0e48d4 2b70 1e00 debug_info_off = 0x001e702b
0x0e48d8 0600 0000 insns_size = 6 → par, así que no hay campo padding
0x0e48dc 3800 … 0e00 insns, 12 bytes
0x0e48e8 0200 0000 try_item.start_addr = 2
0x0e48ec 0300 try_item.insn_count = 3 → cubre 0x0002–0x0004
0x0e48ee 0100 try_item.handler_off = 1 byte dentro de la lista
0x0e48f0 01 encoded_catch_handler_list.size = 1
0x0e48f1 01 encoded_catch_handler.size = +1 → un tipo, sin catch-all
0x0e48f2 87 16 type_idx = 2.823 → Ljava/io/IOException; («sección 8.1 · LEB128»)
0x0e48f4 05 addr = 5 → el handler está en 0x0005
0x0e48f5 00 00 00 Relleno hasta 0x0e48f8, donde empieza el siguiente code_item

handler_off vale 1 porque salta el size de la lista. Y el rango que imprime dexdump (0x0002 - 0x0005) es exclusivo por la derecha, mientras que la especificación define el último cubierto como 0x0004: no es una contradicción, es una convención de impresión distinta que confunde a quien compara salidas.

12. debug_info_item

Sin alineación. Es una máquina de estados byte a byte inspirada en DWARF3 que, al interpretarla, emite la tabla de posiciones (dirección → número de línea) y la información de variables locales de un code_item.

Tiene cinco registros: address (offset en unidades de 16 bits, arranca en 0 y solo puede crecer), line (se inicializa en la cabecera, sube y baja pero nunca por debajo de 1), source_file (inicializado con class_def_item.source_file_idx) y los booleanos prologue_end y epilogue_begin, ambos a falso. La cabecera es uleb128 line_start, uleb128 parameters_size (número de nombres de parámetro, excluyendo el this) y uleb128p1 parameter_names[] (índice en string_ids, o NO_INDEX).

Nombre Valor Argumentos Efecto
DBG_END_SEQUENCE 0x00 — Termina la secuencia
DBG_ADVANCE_PC 0x01 uleb128 addr_diff Avanza address sin emitir posición
DBG_ADVANCE_LINE 0x02 sleb128 line_diff Cambia line sin emitir posición
DBG_START_LOCAL 0x03 uleb128 register_num, uleb128p1 name_idx, uleb128p1 type_idx Declara una local viva en ese registro
DBG_START_LOCAL_EXTENDED 0x04 lo anterior más uleb128p1 sig_idx Ídem, con firma genérica
DBG_END_LOCAL 0x05 uleb128 register_num La local de ese registro sale de ámbito
DBG_RESTART_LOCAL 0x06 uleb128 register_num Reintroduce la última local de ese registro, con su nombre y tipo
DBG_SET_PROLOGUE_END 0x07 — Marca el fin del prólogo
DBG_SET_EPILOGUE_BEGIN 0x08 — Marca el inicio del epílogo
DBG_SET_FILE 0x09 uleb128p1 name_idx Cambia el fichero fuente de las posiciones siguientes
especiales 0x0a…0xff — Avanzan line y address, emiten posición y limpian los dos flags

Los especiales cubren 246 valores y codifican en un byte los incrementos pequeños:

DBG_FIRST_SPECIAL = 0x0a    DBG_LINE_BASE = -4    DBG_LINE_RANGE = 15

adjusted_opcode = opcode - DBG_FIRST_SPECIAL
line    += DBG_LINE_BASE + (adjusted_opcode % DBG_LINE_RANGE)
address += (adjusted_opcode / DBG_LINE_RANGE)

Qué recupera un decompilador de aquí, y qué se pierde. De la tabla de posiciones salen los números de línea, sin los cuales las trazas dicen (Unknown Source) en vez de (Fichero.java:123) y retrace deja de poder mapear líneas. De DBG_START_LOCAL salen los nombres y tipos de las variables locales, sin los cuales el decompilador inventa v0, i, obj; de su variante extendida, los genéricos de esas locales; de parameter_names, los nombres de los parámetros, que si faltan se convierten en arg0, arg1; y de source_file_idx más DBG_SET_FILE, el nombre del fichero fuente.

Eliminarlo es barato y muy rentable para quien ofusca: basta con poner debug_info_off a 0 y source_file_idx a NO_INDEX. El código sigue ejecutándose igual, porque nada de esto participa en la semántica. Lo habitual en una compilación con R8, sin embargo, no es quitarlo todo, sino quedarse con las líneas y tirar los nombres. Se ve en el classes.dex de Droid-ify 780 (la copia de IzzyOnDroid trae el mismo classes.dex). Las cuentas salen de python3 -I scripts/muestrario/cifras/dex_y_bytecode_1.py --depuracion <classes.dex>:

Medida Valor
code_item 30.460
… con debug_info_off == 0 25
… que apuntan a una tabla en la que la línea es el PC más uno 28.777
… que apuntan a otra tabla de líneas 1.658
debug_info_item distintos 1.190
code_item que comparten el debug_info_item más usado 7.689
debug_info_item con nombres de parámetros, DBG_START_LOCAL o DBG_SET_FILE 0
Clases con source_file_idx apuntando a r8-map-id-… 6.320 de 6.456

Cada code_item cuenta una vez: 25 + 28.777 + 1.658 = 30.460. Las 136 clases restantes no llevan atributo de fichero fuente. Casi todos los métodos llevan tabla de líneas y ninguno lleva nombres. Los tres debug_info_item más compartidos, con 7.689, 6.839 y 3.526 métodos, son la codificación por PC de R8: line_start 1, cero, uno o dos parámetros sin nombre (35, 41 y 72 bytes) y un código especial por unidad de código que avanza a la vez el PC y la línea. Los tres empiezan por 0e 1e 1e 1e…: 0e fija la línea 1 y la dirección 0, y cada 1e suma 1 a la línea y 1 a la dirección. La «línea» que muestra una traza es el PC más uno, y la línea real solo se recupera con mapping.txt. Con R8, los debug_info_item distintos son pocos y los comparten muchos métodos. En el classes.dex de Termux 1022 (R8 2.2.71, modo compatibility), en cambio, los métodos traen líneas reales y variables locales: TermuxApplication.onCreate()V empieza con 0x0000 line=25 y declara locals : 0x0000 - 0x0055 reg=5 this Lcom/termux/app/TermuxApplication;. Allí hay 13.026 debug_info_item distintos para 17.896 métodos (1.138 sin debug_info_item), y el más compartido solo lo usan 25. En Droid-ify 780 eran 1.190 para 30.460, y el más compartido lo usan 7.689. De ahí la regla para medir: contar debug_info_item no dice cuántos métodos van sin depuración, porque uno solo lo comparten miles; hay que contar los code_item con debug_info_off == 0.

El muestrario lo confirma («sección 12.1 · Qué información de depuración llevan las apps reales»): en F-Droid, casi nueve de cada diez apps se quedan con las líneas y tiran los nombres.

12.1 Qué información de depuración llevan las apps reales

Un DEX real casi nunca lleva todo ni nada. Para contarlo, clasificamos cada app en un perfil según la suma de sus DEX (unidad: app; denominador: apps con algún code_item). Los umbrales son los de nuestro script y se aplican en este orden:

  1. Sin depuración: al menos el 90 % de sus code_item no tiene debug_info_item.
  2. Con nombres: si no, al menos el 10 % de sus debug_info_item distintos nombra parámetros o variables. Aquí también cuenta un DBG_SET_FILE, así que esta categoría puede estar algo inflada.
  3. Posiciones de R8: si no, al menos la mitad de los code_item con depuración usa la tabla en la que la línea es el PC más uno.
  4. Líneas sin nombres: el resto.
Fuente Apps Posiciones de R8 Líneas sin nombres Sin depuración Con nombres
F-Droid 4.765 43 % 45 % 10 % 3 %
IzzyOnDroid 1.402 48 % 39 % 12 % 1 %
Google Play, las más instaladas 658 52 % 39 % 9 % 0,5 %
Google Play, sorteo 369 34 % 62 % 3 % 0,3 %
Mercado chino 100 20 % 48 % 13 % 19 %

Conservar los nombres es raro en casi todas partes. La excepción es el mercado chino, donde lo hace una de cada cinco apps. Con una definición más laxa (alguno de sus debug_info_item con nombres, variables locales o DBG_SET_FILE, sin umbrales), en F-Droid sube al 27 %. Dos ejemplos de F-Droid: alt.nainapps.aer (versión 1735160000) tiene el perfil «sin depuración», y amirz.rootless.nexuslauncher (versión 30911) tiene nombres de variables.

Contado por métodos, entre una sexta y una cuarta parte de los code_item van sin debug_info_off, según la fuente.

El SourceFile es el nombre de fichero fuente que lleva cada clase. Para cada app tomamos el valor que más clases tiene en su DEX con más clases. En F-Droid gana el nombre real (44 %), y detrás van r8-map-id-… y la cadena fija SourceFile, casi empatados. En las más instaladas de Google Play, SourceFile y el nombre real van a la par, en torno a un tercio cada uno. Un ejemplo de F-Droid con nombre real es SVS.pdfinspector (versión 9). Esto no es lo mismo que el «valor único» tras R8 de «R8 y ProGuard → §9.2 · El atributo SourceFile».

13. access_flags

Los mismos bits sirven en class_def_item, encoded_field, encoded_method y la anotación InnerClass, con significados distintos según el contexto. Ojo a las colisiones en 0x40 y 0x80, que dependen de si el elemento es campo o método.

Nombre Valor Clases Campos Métodos
ACC_PUBLIC 0x1 public public public
ACC_PRIVATE 0x2 private * private private
ACC_PROTECTED 0x4 protected * protected protected
ACC_STATIC 0x8 sin referencia this externa * global a la clase sin argumento this
ACC_FINAL 0x10 no derivable inmutable tras construir no sobrescribible
ACC_SYNCHRONIZED 0x20 — — synchronized. Solo válido si también está ACC_NATIVE
ACC_VOLATILE 0x40 — volatile —
ACC_BRIDGE 0x40 — — Método puente generado por el compilador
ACC_TRANSIENT 0x80 — transient —
ACC_VARARGS 0x80 — — Último argumento variádico
ACC_NATIVE 0x100 — — native
ACC_INTERFACE 0x200 interfaz — —
ACC_ABSTRACT 0x400 abstract — abstract
ACC_STRICT 0x800 — — strictfp
ACC_SYNTHETIC 0x1000 no está en el código fuente ídem ídem
ACC_ANNOTATION 0x2000 clase de anotación — —
ACC_ENUM 0x4000 tipo enumerado valor enumerado —
(sin usar) 0x8000 — — —
ACC_CONSTRUCTOR 0x10000 — — Constructor de clase o de instancia
ACC_DECLARED_SYNCHRONIZED 0x20000 — — Declarado synchronized. No afecta a la ejecución, solo a la reflexión

* ACC_PRIVATE, ACC_PROTECTED y ACC_STATIC solo se admiten en anotaciones InnerClass; nunca deben aparecer en un class_def_item.

Conviene conocer dos al leer código real: ACC_SYNTHETIC, que marca todo lo que generó el compilador —clases de lambda, puentes, accesores de clases internas—, y ACC_CONSTRUCTOR, que acompaña siempre a <init> y <clinit>. Ejemplo real de Droid-ify 780: la combinación access : 0x11008 (STATIC SYNTHETIC CONSTRUCTOR), que aparece 74 veces en su classes.dex; la primera es _COROUTINE.ArtificialStackFramesUnsafe.<clinit>.

En ese DEX, el bit que más se repite con diferencia es public: lo llevan el 94 % de los métodos y casi todos los campos. Le sigue final, en algo más de la mitad de los métodos. Es un solo DEX y los bits de clase no los contamos: no es un histograma de población. El script ejemplos_1.py cuenta los bits de access_flags del class_data_item; con dexdump -d salen contando las líneas access de su salida.

Y ojo, los dos synchronized son cosas distintas: ACC_SYNCHRONIZED hace que el runtime tome el monitor y solo vale con ACC_NATIVE, mientras que ACC_DECLARED_SYNCHRONIZED es puramente informativo, porque en un método no nativo el bloqueo se implementa con monitor-enter y monitor-exit explícitos.

14. Checksums: qué recalcular y en qué orden

Campo Offset Algoritmo Dominio
checksum 0x08 Adler-32 Bytes [12, file_size): el fichero menos magic y menos el propio checksum
signature 0x0c SHA-1 Bytes [32, file_size): el fichero menos magic, checksum y la propia signature

En un contenedor v041, esos intervalos se cuentan desde la cabecera de cada DEX lógico, no desde el inicio del fichero: ART calcula el checksum sobre [header_offset + 12, header_offset + file_size) (DexFile::CalculateChecksum). La receta que sigue, con offsets absolutos, solo vale tal cual para el primer DEX lógico, cuyo header_offset es 0.

La signature está dentro del dominio del checksum. De ahí el orden obligatorio:

1. Escribir todos los cambios estructurales del fichero.
2. Fijar file_size (y, en v041, container_size y header_offset).
3. Calcular SHA-1 sobre [32, file_size) y escribirlo en el offset 0x0c.
4. Calcular Adler-32 sobre [12, file_size) y escribirlo en el offset 0x08.

Hacerlo al revés produce un fichero cuyo checksum no cuadra, porque el paso 3 modifica bytes que el paso 4 ya había resumido: es el fallo número uno de los scripts de parcheo caseros. Y conviene insistir en que la signature no es una firma criptográfica de aplicación, es un identificador de contenido; la firma real del APK vive en el contenedor (ver «Esquemas de firma»).

Lo comprobamos recalculando ambos valores con zlib.adler32 y hashlib.sha1 de Python, que es lo que hace python3 -I scripts/muestrario/cifras/dex_y_bytecode_1.py --checksum <classes.dex>:

classes.dex de com.looker.droidify_780.apk
  checksum  cabecera=0x87484e50  recalculado=0x87484e50  OK
  signature cabecera=7f1baf5a56a91ca1d557d0df130d78c4f5c0a967
            recalculado=7f1baf5a56a91ca1d557d0df130d78c4f5c0a967  OK
classes.dex de com.termux_1022.apk
  checksum  cabecera=0x0637ff08  recalculado=0x0637ff08  OK
  signature cabecera=f76f951b7f4279b3895da67a950037824ca6df18
            recalculado=f76f951b7f4279b3895da67a950037824ca6df18  OK

Las dos apps son de F-Droid: Droid-ify 780 y Termux 1022. En todo el muestrario, el checksum Adler-32 está bien en los 16.158 DEX (0 con el checksum mal).

En la plataforma solo se comprueba el checksum. DexFileVerifier::CheckHeader recalcula el Adler-32 y, si no cuadra, rechaza el fichero con «Bad checksum», o solo avisa con «Ignoring bad checksum» cuando quien lo abre ha pedido no verificarlo (dex_file_verifier.cc, líneas 658-668). La signature no la recalcula nadie: ni el verificador; ni dex2oat, que la copia tal cual al fichero OAT —y el runtime solo comprueba que esa copia y la cabecera coincidan—; ni dexdump -c, que abre el DEX con esa misma verificación y responde Checksum verified sin haber mirado el SHA-1 (dexdump.cc, líneas 2019-2044) («sección 6 de Qué rechaza cada lector · El verificador de DEX»).

En la práctica hay apps publicadas con un SHA-1 que no cuadra. El checksum está bien en los 16.158 DEX, pero el SHA-1 falla en 415. Casi no pasa en Google Play; en cambio afecta al 6 % de las apps de F-Droid y a una de cada cuatro del mercado chino.

La culpa es casi siempre de un compilador antiguo. Todos los DEX hechos con D8 o R8 de la versión 0.2 a la 1.5 lo traen mal (324 de 324). De la 1.6 en adelante, solo 2 de casi 11.000. Otros 88 DEX sin marcador lo traen mal, y no sabemos quién los generó. Tampoco hemos podido establecer por qué escribían mal el SHA-1 esas versiones: probamos los rangos [32, fin), [0, fin) y [12, fin), con y sin el checksum a cero y sin los cuatro últimos bytes, y ninguno lo reproduce. Dos ejemplos de F-Droid con D8 1.0 (versión 035): el classes.dex de 11.508 bytes de com.thermatk.android.xf.fakegapps (versión 3) tiene el checksum 0x84a2e014 bien, la signature de cabecera ba6ced18002aa20bc8496a6f745ab517cbfe7a7c y la recalculada 243e5a99c498519849c76dfa38c7b8ab50ac86ff; com.simonramstedt.yoke (versión 4) también.

Un SHA-1 que no cuadra no impide distribuir la app: hay casos en F-Droid, IzzyOnDroid y Google Play. Lo que medimos es la distribución, no si la app se instala o arranca. Una herramienta que valide el SHA-1 daría un aviso falso en una de cada 17 apps de F-Droid (284 de 4.765). Para ver el cálculo:

import zlib, hashlib, struct
b = open("classes.dex", "rb").read()
print(hex(struct.unpack_from("<I", b, 8)[0]), hex(zlib.adler32(b[12:])))   # checksum
print(b[12:32].hex(), hashlib.sha1(b[32:]).hexdigest())                    # signature

Hay otro rasgo de integridad, propio de algunos protectores: bytes detrás de la sección de datos (data_off + data_size menor que file_size). Pasa en 6 de 4.916 DEX de las más instaladas de Google Play (0,1 %) y en 28 de 890 del mercado chino (3 %), y en ninguno de F-Droid, IzzyOnDroid, el sorteo de Google Play ni las webs de los autores («sección 17.2 · Protectores: el DEX visible es una cáscara»).

14.1 El mismo DEX en dos APK

La signature del DEX identifica el contenido del fichero. La firma del APK identifica a quien lo firmó. Se ven separadas cuando la misma app está en dos repositorios. Droid-ify 0.7.8 está en F-Droid (fdroid/com.looker.droidify_780.apk) y en IzzyOnDroid (izzyondroid/com.looker.droidify_780.apk). Los dos APK tienen distinto SHA-256, pero su classes.dex y su classes2.dex son idénticos byte a byte, con el mismo checksum 0x87484e50 y la misma signature. Se comprueba así:

python3 -I -c "import zipfile;a=zipfile.ZipFile('fdroid/com.looker.droidify_780.apk');b=zipfile.ZipFile('izzyondroid/com.looker.droidify_780.apk');print([a.read(n)==b.read(n) for n in ('classes.dex','classes2.dex')])"

No es un caso aislado. Hay 480 paquetes en F-Droid y en IzzyOnDroid. De los 396 que tienen el mismo nombre de fichero, 262 son idénticos (66 %). De los 134 que no lo son, 104 (78 %) tienen los mismos DEX por nombres, versión, tamaño, recuentos de tablas y orden del map_list. Eso no es «mismos bytes»: aquí no comparamos los bytes, salvo en Droid-ify. Otro ejemplo de pareja con DEX iguales por tamaño y tablas es app.olauncher (versión 113).

15. El límite de 65.536 referencias y multidex

El límite no viene de la cabecera. method_ids_size y field_ids_size son uint de 32 bits sin tope declarado. Viene del bytecode: invoke-virtual, invoke-super, invoke-direct, invoke-static e invoke-interface usan el formato 35c, cuyo layout es A|G|op BBBB F|E|D|C, donde BBBB es una única unidad de 16 bits con el índice de método; sus variantes /range usan 3rc, AA|op BBBB CCCC, con el mismo BBBB; y los accesos a campo (iget/iput en 22c, sget/sput en 21c) usan igualmente un índice de 16 bits. Eso direcciona los índices 0 a 65.535, es decir 65.536 referencias distintas: el 64K reference limit. Para tipos y prototipos el tope está además declarado en la cabecera —«como máximo 65535»— y reforzado en AOSP con un DCHECK_LT(result, 65536U) al construir un TypeIndex.

Las cadenas son la excepción: existe const-string/jumbo (formato 31c) con índice de 32 bits, precisamente para superar el tope. No hay equivalente jumbo para métodos, campos ni tipos, y esa asimetría es la razón de que el límite se enuncie sobre referencias a método.

El tope no es teórico. Ningún DEX del muestrario lo supera, pero muchos se quedan al borde. En Google Play y en el mercado chino, más de la mitad de los DEX pasan del 90 % del tope en métodos referenciados; en F-Droid, uno de cada cuatro. Y unos cuantos lo tocan exactamente: 175 DEX de las más instaladas de Google Play tienen 65.536 métodos justos. Los campos también topan, sobre todo en Google Play y el mercado chino. Tipos y prototipos, en cambio, no se acercan a su tope de 65.535 («sección 3 · header_item campo a campo»): el máximo de type_ids_size es 38.604 y el de proto_ids_size, 32.023.

Las cadenas sí pasan del tope, porque tienen su propia instrucción jumbo. Lo hace entre el 11 % y el 18 % de los DEX según la fuente, y todos usan const-string/jumbo, sin una sola excepción. Algunos lo usan también sin necesitarlo, con 65.536 cadenas o menos: es una elección del compilador. Dos ejemplos: com.github.digitallyrefined.androidipcamera (versión 140, F-Droid) tiene un DEX con más de 65.536 cadenas, y dev.xero.paper (versión 1, IzzyOnDroid) tiene uno con 69.277 string_ids, que necesita const-string/jumbo.

multidex reparte las clases entre varios ficheros —classes.dex, classes2.dex, classes3.dex…, sin huecos en la numeración—, cada uno con sus propias tablas y su propio presupuesto de 65.536 referencias. Una clase solo puede definirse en uno; si aparece en dos, gana la del primer DEX en orden de carga, lo que convierte el orden de los ficheros en información semántica y es lo que hay que preservar al fusionar splits (ver «Fusión de splits»).

La numeración se respeta en todo el muestrario: todas las apps con DEX tienen classes.dex, classes2.dex… sin huecos, sin classes1.dex y en minúsculas. No sabemos cuántas clases se definen en dos DEX de la misma app; solo hemos comprobado que Droid-ify 780 (6.456 clases en classes.dex y 559 en classes2.dex) y Termux 1022 (2.742 y 1) no repiten ninguna. Qué pasa con un hueco o con una clase repetida es comportamiento de ART según la especificación y AOSP: no lo hemos medido.

Desde Android 5.0 (API 21) ART carga varios DEX de forma nativa y multidex está activo por defecto sin biblioteca adicional. Con minSdkVersion 20 o inferior hace falta androidx.multidex, que por debajo de Android 5.0 no basta para esquivar el límite de linearalloc. Hoy es un caso minoritario: entre las apps con varios DEX, como mucho una de cada veinte tiene minSdk 20 o menos. No hemos medido cuántas de ellas llevan la biblioteca MultiDex (androidx.multidex o android.support.multidex). Dos ejemplos de F-Droid con varios DEX y minSdk bajo son app.reading.stoic.stoicreading2 (versión 77, minSdk 15, 2 DEX) y app.seeneva.reader (versión 4, minSdk 16, 2 DEX).

En el muestrario, el número de DEX por app depende mucho de la fuente. Una app de F-Droid lleva casi siempre uno solo (3.327 de 4.765, el 70 %). Una de las más instaladas de Google Play lleva varios (612 de 658, el 93 %), y la mediana es 6: la mitad tiene 6 DEX o más. La tabla cuenta las apps con más de un classes*.dex en la pieza base o única; los splits de funcionalidad se cuentan aparte («sección 15.1 · Apps partidas de Google Play»).

Fuente Apps Multidex 1 DEX 2 3 4–11 más de 11 DEX por app (mediana · p90 · máx.)
F-Droid 4.765 1.438 (30 %) 3.327 899 328 209 2 1 · 3 · 13
IzzyOnDroid 1.402 463 (33 %) 939 301 104 56 2 1 · 3 · 76
Google Play, las más instaladas 658 612 (93 %) 46 68 73 346 125 6 · 15 · 37
Google Play, sorteo 369 293 (79 %) 76 81 78 125 9 3 · 7 · 18
Mercado chino 100 66 (66 %) 34 8 8 25 25 3,5 · 27 · 56
Webs de los autores 7 7 de 7 0 1 2 3 1 4 · 13 · 13

Los récords: 13 DEX en F-Droid, en dos apps empatadas (io.horizontalsystems.bankwallet, versión 180, y org.cosmicide, versión 23); 76 en IzzyOnDroid (it.unige.hidedroid, versión 4); 37 en las más instaladas de Google Play (la pieza base.apk de video.like, versión 5.66.0); 18 en el sorteo (la pieza base.apk de com.nobexinc.wls) y 56 en el mercado chino (com.ss.android.ugc.aweme).

Y un matiz que evita conclusiones erróneas: superar el tope no es la única razón para partir. En Droid-ify 780, classes.dex declara 37.812 method_ids, muy por debajo del límite, y aun así hay un classes2.dex. Al mirarlo, 522 de sus 559 clases llevan el prefijo Lj$/, 36 son Ljava/util/function/* y una es Ljava/io/UncheckedIOException;. Es la biblioteca del núcleo reescrita que emite el core library desugaring de D8/R8, colocada en su propio fichero, y lleva su propio marcador ~~L8 («sección 4.1 · Quién generó un DEX»). Se cuenta con $BT/dexdump classes2.dex | grep 'Class descriptor' | sed -E "s/.*'(L[^/;]*\/?).*/\1/" | sort | uniq -c. En Termux 1022 pasa lo mismo en pequeño: su classes2.dex mide 876 bytes y contiene una sola clase, j$/util/DesugarTimeZone.

¿Cuántas veces es esa la razón? Entre las apps con más de un DEX en la base, la razón dominante sigue siendo el tope, pero no es la única. La tabla da, por fuente, cuántas apps multidex tienen su classes.dex casi lleno (method_ids o field_ids por encima del 90 % de 65.536), cuántas tienen algún DEX casi lleno, cuántas cabrían en un solo DEX si se juntaran sus tablas (la suma de method_ids, la de field_ids y la de type_ids son, cada una, de 65.536 o menos) y cuántas llevan algún DEX marcado ~~L8. Las dos razones se solapan: no se suman los porcentajes. «Cabrían» es una cota inferior, porque la suma cuenta dos veces las referencias repetidas.

Fuente Apps multidex classes.dex casi lleno Algún DEX casi lleno Cabrían en un DEX Algún DEX ~~L8
F-Droid 1.438 67 % 68 % 30 % 34 %
IzzyOnDroid 463 64 % 65 % 32 % 38 %
Google Play, las más instaladas 612 86 % 95 % 4 % 29 %
Google Play, sorteo 293 82 % 90 % 9 % 18 %
Mercado chino 66 83 % 88 % 3 % 8 %

En F-Droid se nota la diferencia: casi un tercio de las apps multidex cabría en un solo DEX, y una de cada tres lleva un DEX aparte con la biblioteca de desugaring.

15.1 Apps partidas de Google Play

Una app de Google Play suele llegar en varias piezas (un .apkm, un .xapk o una carpeta de adb). Ninguna pieza de idioma, de densidad, de ABI ni de texturas lleva DEX. El código está en la pieza base (o en la única, si la app no se divide) y, a veces, en módulos de funcionalidad (dynamic features). La tabla cuenta piezas con DEX sobre las piezas de cada papel:

Papel de la pieza Las más instaladas: con DEX / piezas Sorteo: con DEX / piezas
Base 454 / 454 319 / 319
Única (la app no se divide) 204 / 204 50 / 50
Módulo de funcionalidad 115 / 186 4 / 4
Idioma 0 / 4.412 0 / 352
País 0 / 1 —
Densidad 0 / 1.522 0 / 240
ABI 0 / 1.026 0 / 285
Asset pack 0 / 82 0 / 20
Texturas 0 / 6 0 / 2

Cada módulo de funcionalidad lleva su propio classes.dex y vuelve a numerar desde cero, así que para contar los DEX de una app partida hay que sumar los de cada pieza con código. Es poco habitual: solo un 6 % de las apps más instaladas de Google Play tiene algún split de funcionalidad con DEX, y fuera de Google Play no lo hemos visto. Todas las apps de Google Play tienen DEX. Tres ejemplos, hechos leyendo los ZIP internos de cada .apkm con python3 -I -c "import zipfile,io;z=zipfile.ZipFile('<.apkm>');[print(i.filename,[n for n in zipfile.ZipFile(io.BytesIO(z.read(i))).namelist() if n.startswith('classes')]) for i in z.infolist() if i.filename.endswith('.apk')]":

  • La pieza base.apk de Adobe Acrobat (com.adobe.reader, versión 26.10.0.50639.Beta) lleva 9 DEX, y cinco splits de funcionalidad (split_CaiNativeDF.apk, split_FASOpenCVDF.apk, split_LMCODModelDF.apk, split_ScanSDKDF.apk y split_VADYamnetDF.apk) llevan un classes.dex cada uno.
  • La pieza base.apk de AliExpress (com.alibaba.aliexpresshd, versión 8.179.1) lleva 5 DEX, y seis splits de funcionalidad llevan DEX.
  • La pieza split_pytorchlibrary.apk de com.quvideo.xiaoying (versión 9.38.5) es un split de funcionalidad con 1 DEX; la base tiene 18.

La fusión de estos splits está en «Fusión de splits», y su estructura en «AAB, splits y contenedores».

15.2 El mercado chino

Los DEX de las apps del mercado chino se parecen menos a los demás. De las 100 apps de esa fuente:

  • 67 no llevan marcador de D8 ni de R8.
  • 79 tienen 035 como versión más alta. Un ejemplo es cmb.pb (versión 1447), sin marcador y con versión 035.
  • APKiD pone como herramienta principal dexlib 2.x (la biblioteca de smali) a 58 de las 98 que midió, y r8 a 22 de 98.
  • 66 son multidex y 7 tienen minSdk 20 o menos.
  • 13 llevan Tinker, un marco de parches en caliente. Entre los 40 paquetes más poblados de cada DEX, hay también 1 con RePlugin, 1 con Shadow y ninguno con Sophix, Robust o Atlas. Es una cota inferior: un marco pequeño queda fuera. En las más instaladas de Google Play hay 1 app de 658 con Tinker y 1 con Shadow.
  • El SHA-1 de la cabecera no coincide en 81 de 890 DEX (9 %), y 26 de las 100 apps tienen algún DEX así. Además, 28 de 890 DEX (3 %) llevan bytes tras los datos («sección 14 · Checksums: qué recalcular y en qué orden»).

Un parche en caliente carga DEX nuevos en ejecución: el código que se ejecuta puede no estar en el APK. Esto último es la descripción del marco, no una medida.

16. Recetas

Las verificamos el 31 de octubre de 2026 con build-tools 37.0.0 y baksmali 3.0.7 sobre macOS, sobre el classes.dex de Droid-ify 780. MUESTRARIO es la carpeta con la copia del muestrario («sección 9 de El muestrario · Cómo comprobar un ejemplo»).

BT=~/Library/Android/sdk/build-tools/37.0.0
MUESTRARIO=<carpeta del muestrario>
DEXDIR=$(mktemp -d)
unzip -o -q $MUESTRARIO/fdroid/com.looker.droidify_780.apk 'classes*.dex' -d $DEXDIR
Objetivo Orden
Cabecera del fichero $BT/dexdump -f $DEXDIR/classes.dex | head -24
Cabecera de cada clase $BT/dexdump -h $DEXDIR/classes.dex
Desensamblar el bytecode $BT/dexdump -d $DEXDIR/classes.dex
Volcar todas las cadenas $BT/dexdump -s $DEXDIR/classes.dex
Verificar el checksum $BT/dexdump -c $DEXDIR/classes.dex
Omitir la información de depuración $BT/dexdump -d -n $DEXDIR/classes.dex
Ver anotaciones $BT/dexdump -a $DEXDIR/classes.dex
Los 128 primeros bytes en crudo xxd -l 128 $DEXDIR/classes.dex

Para el map_list no hay orden en las build-tools: se lee el uint del offset 0x34 y desde ahí un uint de cuenta seguido de tuplas <HHII, que es lo que produce el volcado de la «sección 5 · map_list: la vía fiable de recorrer el fichero».

baksmali da una vista textual del mismo contenido, una clase por fichero. Esto es lo que sale con baksmali 3.0.7 sobre el mismo classes.dex:

baksmali disassemble $DEXDIR/classes.dex -o out/
find out -name '*.smali' | wc -l
find out -type f -exec stat -f %z {} + | awk '{s+=$1} END {print s}'
    6456
80560653

Un DEX de 6,7 MB produce unos 80,6 MB de smali (unas 12 veces el DEX) repartidos en 6.456 ficheros, uno por clase, en unos segundos (5 s en la ejecución de esta verificación; el tiempo depende de la máquina). du -sh out marca 91 MB por el tamaño de bloque del disco, así que damos el total en bytes (con apktool 3.0.3 el total es otro, 80.205.904 bytes). En una submuestra de 551 DEX distintos, baksmali escribió un .smali por clase en todos. La mediana fue de 4,7 s en 93 DEX de 5 a 8 MB. Al volver a montar con smali, se recuperaron las mismas clases y las mismas tablas de métodos en 550 de 551. La excepción es el classes3.dex de ViberAndroid (versión 9.6.5.5, web del fabricante): smali quitó un method_id que nada usa (de 65.147 a 65.146). La comparación mira method_ids_size, no los métodos definidos. El detalle de la sintaxis está en «Desensambladores smali».

17. Cuando el DEX no es todo el código

Hasta aquí, el código de una app era lo que hay en classes*.dex. En apps reales hay tres excepciones, y unos ficheros vecinos que se parecen al DEX sin serlo.

17.1 DEX fuera de la raíz

Una app puede llevar DEX en otras carpetas. Para usarlos, tiene que abrirlos ella misma con un cargador de clases. Es algo muy de Google Play: siete de cada diez de las apps más instaladas tienen instrucciones que crean un DexClassLoader o llaman a DexFile.loadDex, frente a un 3,5 % en F-Droid. Eso mide la instrucción, no la presencia del fichero.

La presencia del fichero se mide aparte. Cuenta como «DEX fuera de la raíz» cualquier fichero cuyos primeros bytes son dex\n y cuya ruta no es un classes*.dex de la raíz de una pieza de código. Lo lleva el 39 % de las más instaladas de Google Play, y casi ninguna app de F-Droid ni de IzzyOnDroid. Casi todos (432 de 447) son el SDK de anuncios de Meta, en assets/audience_network/classes.dex, assets/audience_network.dex o assets/audience_network/classes2.dex. El resto es una mezcla: assets/RiskStub.dex, assets/webapk8.dex, dos dentro de lib/arm64-v8a/libsm_impl.so (una .so que contiene un DEX) y unas pocas rutas sueltas, como assets/webapk-1.dex o SafeDKAndroid-m-6.12.7.dex.

Para encontrarlos, fíjate en los primeros bytes de cada fichero, no en el nombre: 5 apps del muestrario tienen ficheros .dex que no son DEX, y buscar por nombre da otros recuentos que por contenido (en el sorteo de Google Play, 64 apps frente a 63; en el mercado chino, 12 frente a 9). Dos ejemplos de ficheros .dex falsos son com.weipaitang.wpt (versión 801, mercado chino) y com.richardluo.globalIconPack (versión 601, IzzyOnDroid). Ejemplos de DEX reales fuera de la raíz:

  • assets/audience_network.dex, de 2.369.470 bytes y comprimido con deflate, en la pieza base.apk de com.olzhas.carparking.multyplayer (versión 4.9.11), que además lleva 7 classes*.dex en la raíz, stored.
  • assets/rish/rish_shizuku.dex, el único DEX fuera de la raíz en F-Droid: app.simple.inure (versión 10724). La copia de IzzyOnDroid es el mismo fichero.

17.2 Protectores: el DEX visible es una cáscara

Algunos protectores guardan el código real aparte, sin que se lea como DEX, y dejan en classes.dex una cáscara con solo lo que hace falta para llegar a él. Se reconoce porque la cabecera y las tablas describen un DEX pequeño, pero el fichero es enorme. Que el código vaya cifrado aparte es una inferencia por el tamaño: no hemos descifrado nada.

El ejemplo es el classes.dex de cn.cj.pe (versión 202608010, mercado chino; Bangcle/SecNeo). Tiene 40 clases y su sección de datos acaba en el byte 44.544, pero el fichero mide 72.478.240 bytes. El map_list acaba también en 44.544 (cierra ahí y no en el file_size). Tras él hay 72.433.696 bytes que no son DEX: empiezan por 12 bytes de cabecera (los valores 1, 72.433.684 y 8) y la cadena dexdata0. El checksum está bien, porque se calculó sobre todo el fichero, y el SHA-1 no coincide. dexdump lo abre sin quejarse (dexdump -c responde Checksum verified) y baksmali desensambla las 40 clases, pero solo ve el cargador. Con el script:

python3 -I scripts/muestrario/cifras/dex_y_bytecode_1.py --mapa classes.dex
python3 -I scripts/muestrario/cifras/dex_y_bytecode_1.py --checksum classes.dex
xxd -s 44544 -l 48 classes.dex

El segundo ejemplo es com.gtgj.view (versión 489, mercado chino; Bangcle/SecNeo): su classes.dex mide 167.529.220 bytes, define 5 clases, su sección de datos acaba en el byte 19.172 y trae el mismo bloque tras el map_list; la app lleva además libDexHelper.so en lib/arm64-v8a/. Un ejemplo de los protectores que elegimos a propósito (solo ejemplo) es com.pplive.androidphone (versión 465), Jiagu 360, con 4 clases en el DEX visible. La cadena dexdata0 solo la comprobamos en los dos DEX de Bangcle/SecNeo de este apartado; no afirmamos que identifique al protector.

Cuántas apps llevan un empaquetador o protector lo contamos con una heurística estática, por nombres de .so, entradas de assets/ y clases del cargador (sin contar PairIP). Es un fenómeno del mercado chino: allí lo llevan 38 de 100 apps, frente a un 2 % de las más instaladas de Google Play y ninguna de F-Droid ni de IzzyOnDroid. En el mercado chino domina Bangcle/SecNeo (21 de las 38), con una mediana de 40 clases visibles, y le sigue Ijiami. Casi un tercio de las apps chinas tiene menos de 1.000 clases en sus DEX. PairIP, que inserta Google Play, va aparte: lo lleva el 7 % de las más instaladas y el 27 % del sorteo. Un ejemplo de Google Play con bytes tras los datos (data_off + data_size = 9.412.208, menor que el file_size, rasgo de DexProtector) es App Cloner Premium (com.applisto.appcloner.premium, versión 4.0.0). Los protectores en general están en «Packers y protectores».

17.3 Apps cuyo código no está en el DEX

En muchas apps el DEX es solo la envoltura Java. El código de la app está en otro sitio: en Dart (Flutter), en JavaScript (React Native), en C# o C++ (Unity). Quien abre su DEX encuentra pocas clases de la app. Las pistas están en el propio DEX (paquetes como io.flutter, com.facebook.react, com.unity3d.player o mono.android) y en las bibliotecas nativas. Es más común de lo que parece: lo lleva una de cada seis apps de F-Droid y dos de cada tres del mercado chino. Una app puede llevar varios, y llevar uno no quiere decir que toda la app esté hecha con él. Flutter es el que más se ve en F-Droid; Unity, en Google Play, y React Native, en el mercado chino. Un ejemplo con React Native es la pieza base.apk de Facebook (com.facebook.katana, versión 584.0.0.51.56), con el paquete com.facebook.react en su DEX. Es una cota inferior: miramos solo los 40 paquetes más poblados de cada DEX. Las cifras por marco están en «Código nativo y ELF».

17.4 Ficheros vecinos del DEX

Junto al DEX hay otros ficheros que se le parecen y no lo son. Los que genera el sistema en el dispositivo (.odex, .vdex, .oat, .art) no viajan en el APK: no aparece ni uno en ninguna de las apps del muestrario. Sí viaja assets/dexopt/baseline.prof, el perfil que dice qué métodos conviene compilar de antemano. Lo lleva la mayoría: siete de cada diez apps de F-Droid y nueve de cada diez de las más instaladas de Google Play; en el mercado chino, la mitad. Con baseline.profm, su compañero, las cifras son casi iguales. Un ejemplo de F-Droid con los dos es InfinityLoop1309.NewPipeEnhanced (versión 110904; la copia de IzzyOnDroid también). Qué pasa con este perfil al modificar un DEX no lo hemos medido.

Fuentes

  1. Dalvik executable format — https://source.android.com/docs/core/runtime/dex-format Consultado el 12 de agosto de 2026 («Last updated 2025-10-03 UTC»). Fuente primaria de casi todo: header_item, códigos TYPE_*, tablas de índices, descriptores, LEB128 y MUTF-8, encoded_value, anotaciones, class_data_item, code_item, debug_info_item y access_flags (secciones «3» y «5» a 13). Reconsultado el 18 de octubre de 2026, cuando la página dice «Last updated 2026-10-09 UTC»: lo que de ella cita este documento sigue igual —las notas de las versiones 037 a 041, el 0x70 de TYPE_HEADER_ITEM y el 0x78 de header_size en v41, y las alineaciones de la «sección 2 · Convenciones del formato»—. De esa consulta salen además la alineación a 4 bytes de call_site_id_item y method_handle_item (secciones «1» y «2») y los campos de encoded_annotation, annotation_element, annotation_set_ref_list y annotation_set_ref_item («sección 9.1 · encoded_annotation y annotation_set_ref_list»), la sección «Container format» —«mostly just naive concatenation», «All offsets are relative to the physical file»— y la descripción de file_size, container_size y header_offset en v41 («sección 5.1 · Cómo recorrer un contenedor 041»), y que hiddenapi_class_data_item «is only applicable to the DEX files of classes in the boot class path» («sección 5 · map_list: la vía fiable de recorrer el fichero»).
  2. Dalvik bytecode format — https://source.android.com/docs/core/runtime/dalvik-bytecode Consultado el 12 de agosto de 2026 («Last updated 2025-01-07 UTC»). De aquí sale const-string/jumbo y el detalle de invoke-custom de las secciones «6» y «15».
  3. Dalvik executable instruction formats — https://source.android.com/docs/core/runtime/instruction-formats Consultado el 12 de agosto de 2026 («Last updated 2024-08-26 UTC»). De aquí salen los layouts 35c, 3rc, 21c, 22c y 31c que fijan el límite de la «sección 15 · El límite de 65.536 referencias y multidex».
  4. AOSP art/libdexfile/dex/standard_dex_file.cc — https://android.googlesource.com/platform/art/+/refs/tags/android-17.0.0_r1/libdexfile/dex/standard_dex_file.cc Consultado el 25 de septiembre de 2026. De aquí sale kDexMagicVersions con las seis versiones aceptadas y el motivo de que no exista la 036 («sección 4 · magic y la tabla de versiones»).
  5. AOSP art/libdexfile/dex/dex_file.h — https://android.googlesource.com/platform/art/+/refs/tags/android-17.0.0_r1/libdexfile/dex/dex_file.h Consultado el 25 de septiembre de 2026. De aquí salen kDexEndianConstant, kDexNoIndex32, kSha1DigestSize, kDexContainerVersion = 41, los campos container_size_ y header_offset_ («sección 3 · header_item campo a campo») y el DCHECK_LT(result, 65536U) («sección 15 · El límite de 65.536 referencias y multidex»).
  6. AOSP art/libdexfile/dex/standard_dex_file.h — https://android.googlesource.com/platform/art/+/refs/tags/android-17.0.0_r1/libdexfile/dex/standard_dex_file.h Consultado el 25 de septiembre de 2026. De aquí sale kNumDexVersions = 6 («sección 4 · magic y la tabla de versiones»).
  7. Enable multidex for apps with over 64K methods — https://developer.android.com/build/multidex Consultado el 12 de agosto de 2026. De aquí salen el enunciado del límite, el soporte nativo desde API 21 y androidx.multidex para minSdkVersion ≤ 20 («sección 15 · El límite de 65.536 referencias y multidex»). Reconsultado el 18 de octubre de 2026 («Last updated 2026-10-16 UTC»): de aquí sale que, «When running on versions prior to Android 5.0 (API level 21)», multidex no basta para esquivar el límite de linearalloc («sección 15 · El límite de 65.536 referencias y multidex»).
  8. baksmali 3.0.7 — https://github.com/google/smali Instalado y ejecutado el 31 de octubre de 2026 sobre el classes.dex de Droid-ify 780. De aquí salen el recuento de 6.456 ficheros .smali y los 80,6 MB de salida de la «sección 16 · Recetas».
  9. AOSP — art/libdexfile/dex/dex_file_verifier.cc y art/runtime/class_linker.cc, etiqueta android-17.0.0_r1 — https://android.googlesource.com/platform/art/+/refs/tags/android-17.0.0_r1/libdexfile/dex/dex_file_verifier.cc y https://android.googlesource.com/platform/art/+/refs/tags/android-17.0.0_r1/runtime/class_linker.cc Consultados el 25 de septiembre de 2026. De aquí salen CheckOrder, que solo rechaza un índice que retrocede, y la tolerancia a las repeticiones de b/21868015 («sección 10 · class_def_item y class_data_item»).
  10. AOSP — art/libdexfile/dex/dex_file.cc y dex_file.h, etiqueta android-17.0.0_r1 — https://android.googlesource.com/platform/art/+/refs/tags/android-17.0.0_r1/libdexfile/dex/dex_file.cc Consultado el 25 de septiembre de 2026. De aquí sale que CalculateChecksum suma desde Begin() + 12 hasta Size(), donde Begin() es la cabecera del DEX lógico y Size() su file_size («sección 14 · Checksums: qué recalcular y en qué orden»).
  11. AOSP — art/libdexfile/dex/standard_dex_file.cc, dex_file_loader.cc y dex_file_verifier.cc, etiquetas android-10.0.0_r1, android-10.0.0_r47, android-11.0.0_r1, android-14.0.0_r1 a android-14.0.0_r75, android-15.0.0_r1, android-16.0.0_r1 y android-17.0.0_r1 — https://android.googlesource.com/platform/art/+/refs/tags/android-17.0.0_r1/libdexfile/dex/standard_dex_file.cc Consultado el 25 de septiembre de 2026. De aquí salen en qué etiquetas están 040 y 041 en kDexMagicVersions, con el recorrido de contenedores y las comprobaciones de v41 («sección 4 · magic y la tabla de versiones»), y que IsValidMemberName no mira la versión («sección 7 · Descriptores de tipo y shorty»). La tabla de la nota sobre la 041 se reconsultó el 18 de octubre de 2026 en android-14.0.0_r1, r28, r29, r37, r38, r45, r50, r60 y r75, y en android-15.0.0_r1, android-16.0.0_r1 y android-17.0.0_r1, donde el comentario de la 041 está en la línea 39 de standard_dex_file.cc.
  12. Android Runtime (ART) — Android Open Source Project — https://source.android.com/docs/core/ota/modular-system/art Consultado el 25 de septiembre de 2026. De aquí sale que ART es un módulo actualizable («sección 4 · magic y la tabla de versiones»).
  13. R8/D8, commit 084a891 (el de D8 9.2.4-dev de las build-tools 37.0.0) — https://r8.googlesource.com/r8/+/084a89126ae0596c599143df57a654646af28313/src/main/java/com/android/tools/r8/utils/InternalOptions.java Consultado el 25 de septiembre de 2026, con AndroidApiLevel.java, DexVersion.java, dex/Constants.java y dex/ApplicationWriter.java del mismo commit. De aquí salen la propiedad com.android.tools.r8.dexContainerExperiment, el nivel BAKLAVA del formato contenedor y TYPE_HEADER_ITEM_SIZE_V41 = 0x78 (secciones «4» y «5»).
  14. AOSP — art/libdexfile/dex/dex_file_verifier.cc, dex_file_loader.cc, dex_file.cc y dex_file.h, art/dexdump/dexdump.cc, art/dex2oat/linker/oat_writer.cc y art/runtime/oat/oat_file.cc, etiqueta android-17.0.0_r1 — https://android.googlesource.com/platform/art/+/refs/tags/android-17.0.0_r1/libdexfile/dex/dex_file_verifier.cc Consultado el 18 de octubre de 2026. De aquí salen el recorrido del contenedor de DexFileLoader (dex_file_loader.cc, líneas 440-465; la misma cuenta en las 221-240), el inicio del contenedor como base de los offsets (DexFile::GetDataRange, dex_file.cc, líneas 247-265; GetDexContainerRange e IsDexContainerLastEntry, dex_file.h, líneas 295-303) y las comprobaciones de v41 de la tabla de la «sección 5.1 · Cómo recorrer un contenedor 041»; que CheckHeader recalcula el Adler-32 y falla con «Bad checksum» o avisa con «Ignoring bad checksum» (dex_file_verifier.cc, líneas 658-668), que ni el verificador ni dexdump -c (dexdump.cc, líneas 2019-2044) recalculan el SHA-1, y que dex2oat lo copia al OAT (oat_writer.cc, líneas 3980 y 4031) y el runtime solo compara esa copia con la cabecera (oat_file.cc, líneas 980 y 2314-2321) («sección 14 · Checksums: qué recalcular y en qué orden»).
  15. Build numbers — Android Open Source Project — https://source.android.com/docs/setup/reference/build-numbers Consultado el 18 de octubre de 2026 («Last updated 2026-09-10 UTC»). De aquí salen las compilaciones de cada etiqueta android-14.0.0_r* de la nota sobre la 041: UP1A, UD1A y UQ1A hasta r28, AP1A de r29 a r37, UD2A para el Pixel 8a de r38 a r45 y AP2A en r50, r60 y r75 («sección 4 · magic y la tabla de versiones»).