Formato DEX
Antes conviene leer «Anatomía de un APK»
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í:
- La primera cabecera está en el offset 0.
- Su
file_sizeno es el tamaño del fichero, sino la distancia hasta la cabecera siguiente: la próxima está enheader_offset + file_size. - Se sigue mientras
header_offset + file_sizesea menor quecontainer_size; el últimoDEXlógico es el que acaba justo ahí. - Cada cabecera lleva su propia posición en
header_offsety el tamaño del fichero entero encontainer_size.data_sizeydata_offya no se usan. - Todos los offsets —los de la cabecera, los del
map_listy los de dentro dedata— cuentan desde el inicio del contenedor, nunca desde la cabecera: «All offsets are relative to the physical file». UnDEXlógico puede apuntar a datos que vayan detrás, en otroDEXló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.214DEX): «CI DI TL SD CD ML» en 7.931. Es el orden de Droid-ify 780, cuyomap_listcompleto es H S T P F M C CI DI TL SD AI CD EA AS AD ML. - Con marcador
D8(3.105DEX): el mismo orden en 2.735, y «CI TL SD CD ML», sindebug_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
DEXde las apps que midió enteras): «SD TL DI CI CD ML» es dedexlib 2.xen 1.168DEXy queda sin etiqueta en 75. «ML TL CD CI SD DI», con elmap_listjusto tras lasclass_defs, es dedx (possible dexmerge)en 118DEXy der8 (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.
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:
- Solo se usan las formas de uno, dos y tres bytes. Nunca cuatro.
- Los code points
U+10000–U+10ffffse codifican como par subrogado, cada mitad con su forma de tres bytes: seis bytes donde UTF-8 usaría cuatro. - El code point
U+0000se codifica en dos bytes (c0 80), no en uno. - 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 solo00y la cadena se habría cortado tras laa."ñ"→c3 b1, idéntico a UTF-8: por debajo deU+0800no hay diferencia."😀"→ed a0 bd(U+D83D) +ed b8 80(U+DE00), el par subrogado. UTF-8 estándar habría emitidof0 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:
- Sin depuración: al menos el 90 % de sus
code_itemno tienedebug_info_item. - Con nombres: si no, al menos el 10 % de sus
debug_info_itemdistintos nombra parámetros o variables. Aquí también cuenta unDBG_SET_FILE, así que esta categoría puede estar algo inflada. - Posiciones de
R8: si no, al menos la mitad de loscode_itemcon depuración usa la tabla en la que la línea es el PC más uno. - 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.apkde Adobe Acrobat (com.adobe.reader, versión 26.10.0.50639.Beta) lleva 9DEX, y cinco splits de funcionalidad (split_CaiNativeDF.apk,split_FASOpenCVDF.apk,split_LMCODModelDF.apk,split_ScanSDKDF.apkysplit_VADYamnetDF.apk) llevan unclasses.dexcada uno. - La pieza
base.apkde AliExpress (com.alibaba.aliexpresshd, versión 8.179.1) lleva 5DEX, y seis splits de funcionalidad llevanDEX. - La pieza
split_pytorchlibrary.apkdecom.quvideo.xiaoying(versión 9.38.5) es un split de funcionalidad con 1DEX; 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
D8ni deR8. - 79 tienen
035como versión más alta. Un ejemplo escmb.pb(versión 1447), sin marcador y con versión035. - APKiD pone como herramienta principal
dexlib 2.x(la biblioteca desmali) a 58 de las 98 que midió, yr8a 22 de 98. - 66 son multidex y 7 tienen
minSdk20 o menos. - 13 llevan
Tinker, un marco de parches en caliente. Entre los 40 paquetes más poblados de cadaDEX, hay también 1 conRePlugin, 1 conShadowy ninguno conSophix,RobustoAtlas. Es una cota inferior: un marco pequeño queda fuera. En las más instaladas de Google Play hay 1 app de 658 conTinkery 1 conShadow. - El SHA-1 de la cabecera no coincide en 81 de 890
DEX(9 %), y 26 de las 100 apps tienen algúnDEXasí. Además, 28 de 890DEX(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 piezabase.apkdecom.olzhas.carparking.multyplayer(versión 4.9.11), que además lleva 7classes*.dexen la raíz, stored.assets/rish/rish_shizuku.dex, el únicoDEXfuera 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
- 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ódigosTYPE_*, tablas de índices, descriptores, LEB128 yMUTF-8,encoded_value, anotaciones,class_data_item,code_item,debug_info_itemyaccess_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, el0x70deTYPE_HEADER_ITEMy el0x78deheader_sizeen v41, y las alineaciones de la «sección 2 · Convenciones del formato»—. De esa consulta salen además la alineación a 4 bytes decall_site_id_itemymethod_handle_item(secciones «1» y «2») y los campos deencoded_annotation,annotation_element,annotation_set_ref_listyannotation_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 defile_size,container_sizeyheader_offseten v41 («sección 5.1 · Cómo recorrer un contenedor 041»), y quehiddenapi_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»). - 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/jumboy el detalle deinvoke-customde las secciones «6» y «15». - 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,22cy31cque fijan el límite de la «sección 15 · El límite de 65.536 referencias y multidex». - 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í salekDexMagicVersionscon las seis versiones aceptadas y el motivo de que no exista la 036 («sección 4 · magic y la tabla de versiones»). - 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í salenkDexEndianConstant,kDexNoIndex32,kSha1DigestSize,kDexContainerVersion = 41, los camposcontainer_size_yheader_offset_(«sección 3 · header_item campo a campo») y elDCHECK_LT(result, 65536U)(«sección 15 · El límite de 65.536 referencias y multidex»). - 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í salekNumDexVersions = 6(«sección 4 · magic y la tabla de versiones»). - 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.multidexparaminSdkVersion≤ 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)»,multidexno basta para esquivar el límite delinearalloc(«sección 15 · El límite de 65.536 referencias y multidex»). - baksmali 3.0.7 — https://github.com/google/smali
Instalado y ejecutado el 31 de octubre de 2026 sobre el
classes.dexde Droid-ify 780. De aquí salen el recuento de 6.456 ficheros.smaliy los 80,6 MB de salida de la «sección 16 · Recetas». - AOSP —
art/libdexfile/dex/dex_file_verifier.ccyart/runtime/class_linker.cc, etiquetaandroid-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í salenCheckOrder, 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»). - AOSP —
art/libdexfile/dex/dex_file.ccydex_file.h, etiquetaandroid-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 queCalculateChecksumsuma desdeBegin() + 12hastaSize(), dondeBegin()es la cabecera delDEXlógico ySize()sufile_size(«sección 14 · Checksums: qué recalcular y en qué orden»). - AOSP —
art/libdexfile/dex/standard_dex_file.cc,dex_file_loader.ccydex_file_verifier.cc, etiquetasandroid-10.0.0_r1,android-10.0.0_r47,android-11.0.0_r1,android-14.0.0_r1aandroid-14.0.0_r75,android-15.0.0_r1,android-16.0.0_r1yandroid-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án040y041enkDexMagicVersions, con el recorrido de contenedores y las comprobaciones de v41 («sección 4 · magic y la tabla de versiones»), y queIsValidMemberNameno 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 enandroid-14.0.0_r1,r28,r29,r37,r38,r45,r50,r60yr75, y enandroid-15.0.0_r1,android-16.0.0_r1yandroid-17.0.0_r1, donde el comentario de la 041 está en la línea 39 destandard_dex_file.cc. - 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
ARTes un módulo actualizable («sección 4 · magic y la tabla de versiones»). - R8/D8, commit
084a891(el deD89.2.4-dev de lasbuild-tools37.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, conAndroidApiLevel.java,DexVersion.java,dex/Constants.javaydex/ApplicationWriter.javadel mismo commit. De aquí salen la propiedadcom.android.tools.r8.dexContainerExperiment, el nivelBAKLAVAdel formato contenedor yTYPE_HEADER_ITEM_SIZE_V41 = 0x78(secciones «4» y «5»). - AOSP —
art/libdexfile/dex/dex_file_verifier.cc,dex_file_loader.cc,dex_file.ccydex_file.h,art/dexdump/dexdump.cc,art/dex2oat/linker/oat_writer.ccyart/runtime/oat/oat_file.cc, etiquetaandroid-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 deDexFileLoader(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;GetDexContainerRangeeIsDexContainerLastEntry,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»; queCheckHeaderrecalcula 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 nidexdump -c(dexdump.cc, líneas 2019-2044) recalculan el SHA-1, y quedex2oatlo 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»). - 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,UD1AyUQ1Ahastar28,AP1Ader29ar37,UD2Apara el Pixel 8a der38ar45yAP2Aenr50,r60yr75(«sección 4 · magic y la tabla de versiones»).