XML binario de Android (AXML)

Antes conviene leer «Anatomía de un APK» · se lee en paralelo con «Tabla de recursos»

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

Todos los enteros de este documento son little-endian: el byte menos significativo va primero. El número 0x3918 se guarda en el fichero como 18 39.

Convenciones que se usan en todo el documento:

  • Un offset es la posición de un dato, contada en bytes desde un punto que cada tabla indica (el inicio del fichero, del chunk o de la extensión).
  • 0x abre un número en hexadecimal. uint16_t y uint32_t son enteros sin signo de 2 y de 4 bytes.
  • Los índices cuentan desde 0, salvo idIndex, classIndex y styleIndex, que cuentan desde 1 y valen 0 si no hay atributo.
  • 0xFFFFFFFF en un campo que apunta a una cadena significa «ninguna».

Hay dos tipos de medida. El manifiesto lo hemos leído en las 15.183 piezas del muestrario. El interior de los AXML (los XML de res/, resources.arsc, los valores, los CDATA…) solo lo hemos leído en una pasada sobre 197 piezas: las 100 del mercado chino, las cinco de protectores y unas 90 de los demás orígenes. Fuera del mercado chino son pocas, así que esas cifras del interior no se pueden leer como «todo el muestrario».

1. Qué es y por qué existe

Dentro de un APK casi no hay XML en texto. AndroidManifest.xml y todo lo que cuelga de res/layout/, res/xml/, res/anim/ y los .xml de res/drawable/ están en AXML, el formato binario que produce aapt2 al compilar. Las excepciones principales son res/raw/ y assets/, que aapt2 copia tal cual: un .xml ahí sigue siendo texto. Si haces cat AndroidManifest.xml sobre un APK descomprimido, te sale basura: los cuatro primeros bytes son 03 00 08 00, no <?xm.

Un ejemplo real: el manifiesto de Termux (com.termux, versión 1022, de F-Droid) empieza por 03 00 08 00 18 39 00 00. Son el tipo 0x0003, el tamaño de cabecera 8 y el tamaño total 0x3918, 14.616 bytes, el del fichero entero. Lo mismo pasa en los 15.183 manifiestos del muestrario: ninguno tiene otro tipo en la raíz, ninguno declara un tamaño distinto del real y el medidor pudo leerlos todos.

La regla «el XML de un APK está en AXML» no es tan limpia como parece. En la pasada de 197 piezas separamos el contenido (los cuatro primeros bytes del fichero) del nombre (la extensión .xml) y salieron cuatro rarezas:

  • En res/raw/ no hemos encontrado ningún AXML, en ninguna de las 197 piezas.
  • Algunos assets/ llevan AXML ya compilado. El base.apk de UC Browser (com.uc.browser.en 12.13.0.1291, de APKMirror) trae 315, y es la única pieza de Google Play que lo hace. En el mercado chino lo hacen 4 de 100; en las demás fuentes, ninguna.
  • A la inversa, hay XML en texto dentro de res/, fuera de res/raw/: 27 de 100 piezas del mercado chino, 5 de 25 de Google Play y 4 de 7 de webs de autores. En F-Droid, ninguna.
  • 15 de 100 piezas del mercado chino guardan XML compilado en una carpeta que no es res/ ni assets/ (por ejemplo r/): 154.672 ficheros en total. El APK de Douyin (com.ss.android.ugc.aweme 400801) lleva 28.898 y ninguno dentro de res/. Un lector que busque AXML solo en res/ no los ve. En las demás fuentes no hay ninguno.

Por eso hay que mirar los primeros bytes del fichero (03 00 08 00) y no fiarse de la carpeta ni de la extensión.

La razón del formato es el arranque. PackageManager lee el manifiesto de cada aplicación instalada en cada arranque, y AssetManager infla layouts en el camino crítico de cada Activity. AXML llega ya resuelto: un array plano de estructuras de tamaño fijo, con las cadenas deduplicadas en una tabla al principio y los valores ya convertidos a su tipo final. Un color escrito #ff0000 en el fuente llega al dispositivo como el entero 0xffff0000 etiquetado TYPE_INT_COLOR_RGB8; nadie vuelve a analizar la cadena.

Veámoslo con bytes reales. En texto (reconstruido por apktool, que no recupera el original), la primera línea del manifiesto de Termux empieza así:

<manifest xmlns:android="http://schemas.android.com/apk/res/android" android:compileSdkVersion="30" … android:sharedUserId="com.termux" … package="com.termux" …>

En AXML no hay etiquetas. El elemento manifest es un bloque de 236 bytes con diez atributos de 20 bytes cada uno. El primero, sharedUserId="com.termux", ocupa estos 20 bytes (en +0x1b60 del manifiesto de Termux):

6d 00 00 00  06 00 00 00  56 00 00 00  08 00 00 03  56 00 00 00
ns=109       nombre=6     texto=86     tamaño=8, tipo 3 (cadena), dato=86

Ningún campo guarda la palabra sharedUserId: guarda el número de una cadena de la tabla (la 6) y otro número (la 86, que es com.termux). El resto del documento explica cómo se llega de esos números al texto. apktool ordena los atributos alfabéticamente; el AXML los guarda por orden de resource ID (sharedUserId es 0x0101000b, versionCode es 0x0101021b…). El volcado sale de scripts/muestrario/cifras/manifiesto_1.py --volcar (receta 8.2).

Se gana lectura rápida, memoria acotada y un fichero mapeable. Se pierde el fuente: AXML no guarda indentación, ni comentarios (reserva un hueco para ellos, pero en lo que hemos medido siempre va vacío), ni si un booleano se escribió true o TRUE. Toda herramienta que muestre el manifiesto en texto —aapt2 dump xmltree, apktool, jadx— está reconstruyendo una representación plausible, no recuperando el original. Dos manifiestos distintos pueden compilar al mismo AXML, y un AXML admite varias reconstrucciones igualmente válidas. Esa asimetría está detrás de buena parte de los fallos de reempaquetado que recoge «Diagnóstico de fallos».

Lo de los comentarios lo hemos comprobado: cada nodo reserva un campo (comment), pero en los 197 manifiestos y los 499.986 XML de res/ de la pasada vale siempre 0xFFFFFFFF, que significa «ninguno». Es una medida de esa pasada, no de las 15.183 piezas.

1.1 Cómo ver el manifiesto de un APK

Hay tres formas de leer el manifiesto sin instalar la app. Las tres leen el AXML y escriben texto, y por eso no dan el mismo texto.

# 1. aapt2: enseña lo que hay en el fichero, sin interpretarlo
aapt2 dump xmltree --file AndroidManifest.xml com.termux_1022.apk

# 2. apktool: reconstruye el XML de verdad y resuelve las referencias contra resources.arsc
apktool d -f -o salida com.termux_1022.apk

# 3. jadx: reconstruye el XML y deja el manifiesto en resources/AndroidManifest.xml
jadx --no-src -d salida net.typeblog.shelter_445.apk

aapt2 enseña sharedUserLabel=@0x7f1000d9; apktool escribe android:sharedUserLabel="@string/shared_user_label". Es el mismo valor: apktool lo busca en la tabla de recursos. Las órdenes 1 y 2 las ejecutamos sobre Termux (apktool tarda 3 s y escribe 2.743 ficheros smali) y la 3, sobre Shelter (net.typeblog.shelter 445). apkanalyzer manifest print también existe, pero no lo hemos probado.

1.2 El AXML en el muestrario

Un manifiesto es un fichero pequeño. Estas son las medianas de los APK completos (la pieza base o la única) según el origen: los bytes del manifiesto, las cadenas de su pool (stringCount) y los IDs de su resource map (secciones «3» y «6»).

Origen Bytes Cadenas IDs en el mapa
F-Droid 8.274 83 27
IzzyOnDroid 9.156 88 28
Google Play (las más instaladas) 74.982 412 55
Google Play (sorteo) 31.292 208 42
Mercado chino 171.980 834 56
Webs de los autores 106.512 563 56

Los extremos dan una idea de la dispersión: en F-Droid van de 1.400 a 785.972 bytes, en Google Play de 2.112 a 1.014.548 y en el mercado chino de 15.320 a 1.073.764. Los splits de Google Play llevan manifiestos mínimos: la mediana ronda los 1.000 bytes.

También miramos qué tipo de valor llevan los atributos, solo en los manifiestos de la pasada de 197 piezas (son recuentos de atributos, no de piezas). Lo más habitual son las cadenas (nombres de clases, de permisos…), con más de la mitad en F-Droid y Google Play y algo menos de la mitad en el mercado chino, seguidas de los booleanos y las referencias a recursos. En el mercado chino pesan bastante más los enteros, decimales y hexadecimales, que suman casi un tercio.

Cuántos AXML lleva un APK no lo sabemos por pieza: la pasada solo da el total (499.986 XML de res/ en 197 piezas).

Cómo repetir las medidas. Los manifiestos de las 15.183 piezas: MUESTRARIO_RAIZ=<carpeta del muestrario> python3 -I scripts/muestrario/cifras/manifiesto_1.py --salida <fichero.json>. El interior de los AXML (197 piezas) sale de la misma herramienta: --barrido <salida> --seleccion {submuestra,cx,canal,shared_user_id} lee las piezas y --axml <carpeta> reúne los resultados. Con --volcar <AXML> se vuelcan los chunks de un fichero (receta 8.2).

2. El sustrato de chunks

AXML y «resources.arsc» no son dos formatos: son dos dialectos del mismo sustrato binario. Se documenta aquí; el otro documento enlaza a esta sección en lugar de repetirla.

2.1 ResChunk_header

Toda unidad estructural —un chunk («glosario»)— empieza por la misma cabecera de 8 bytes:

Campo Offset Tamaño Tipo Significado
type 0x00 2 uint16_t Identificador de tipo. Su significado depende del chunk contenedor
headerSize 0x02 2 uint16_t Tamaño de esta cabecera. Sumado a la dirección del chunk, apunta a sus datos
size 0x04 4 uint32_t Tamaño total, cabecera incluida. Sumado a la dirección del chunk, apunta al siguiente

La propiedad que hace viable todo lo demás está en el comentario de AOSP sobre size: «Adding this value to the chunk allows you to completely skip its contents (including any child chunks)». O sea:

Un lector puede saltarse un chunk que no entiende sin perderlo y sin desalinearse.

Eso hace el formato extensible hacia delante y permite algo mejor a una herramienta de edición: leer un fichero, modelar tipadamente solo lo que se entiende, conservar en crudo el resto y reemitir el conjunto byte a byte. Es la estrategia que se sigue con resources.arsc, y la razón de que el round-trip byte-exacto sea alcanzable sin implementar el cien por cien del formato.

Los dos tamaños son independientes. headerSize puede ser mayor que la estructura que el lector conoce: significa que una versión posterior de Android añadió campos, y hay que saltar hasta headerSize en vez de asumir el sizeof propio. Es el mismo mecanismo que hace crecer a ResTable_config («sección 8.2 de Tabla de recursos · El problema del size variable»).

2.2 Los valores de type

Del enum anónimo de ResourceTypes.h:

Nombre simbólico Valor Dónde aparece
RES_NULL_TYPE 0x0000 Relleno; también lo que queda si se pisa una cabecera
RES_STRING_POOL_TYPE 0x0001 AXML y resources.arsc
RES_TABLE_TYPE 0x0002 Raíz de resources.arsc
RES_XML_TYPE 0x0003 Raíz de un fichero AXML
RES_XML_FIRST_CHUNK_TYPE 0x0100 Marca de rango, igual a RES_XML_START_NAMESPACE_TYPE
RES_XML_START_NAMESPACE_TYPE 0x0100 Dentro de RES_XML_TYPE
RES_XML_END_NAMESPACE_TYPE 0x0101 Dentro de RES_XML_TYPE
RES_XML_START_ELEMENT_TYPE 0x0102 Dentro de RES_XML_TYPE
RES_XML_END_ELEMENT_TYPE 0x0103 Dentro de RES_XML_TYPE
RES_XML_CDATA_TYPE 0x0104 Dentro de RES_XML_TYPE
RES_XML_LAST_CHUNK_TYPE 0x017f Marca de rango
RES_XML_RESOURCE_MAP_TYPE 0x0180 Dentro de RES_XML_TYPE. Opcional
RES_TABLE_PACKAGE_TYPE 0x0200 Dentro de RES_TABLE_TYPE
RES_TABLE_TYPE_TYPE 0x0201 Dentro de RES_TABLE_PACKAGE_TYPE
RES_TABLE_TYPE_SPEC_TYPE 0x0202 Dentro de RES_TABLE_PACKAGE_TYPE
RES_TABLE_LIBRARY_TYPE 0x0203 Dentro de RES_TABLE_PACKAGE_TYPE
RES_TABLE_OVERLAYABLE_TYPE 0x0204 Dentro de RES_TABLE_PACKAGE_TYPE
RES_TABLE_OVERLAYABLE_POLICY_TYPE 0x0205 Dentro de RES_TABLE_OVERLAYABLE_TYPE
RES_TABLE_STAGED_ALIAS_TYPE 0x0206 Dentro de RES_TABLE_PACKAGE_TYPE
RES_TABLE_FLAGGED 0x0207 Dentro de RES_TABLE_PACKAGE_TYPE. En android-17.0.0_r1, no en main
RES_TABLE_FLAG_LIST 0x0208 Dentro de RES_TABLE_TYPE. En android-17.0.0_r1, no en main

Los dos últimos son nuevos en android-17.0.0_r1 (ResourceTypes.h:264-265; la cabecera de android-16.0.0_r1 no los define) y no están en main; los desarrolla la «sección 12.5 de Tabla de recursos · RES_TABLE_FLAGGED (0x0207) y RES_TABLE_FLAG_LIST (0x0208)».

Ningún resources.arsc del muestrario usa todavía RES_TABLE_FLAGGED ni RES_TABLE_FLAG_LIST: de las 13.656 tablas que leímos, ninguna los lleva. Eso es un dato de existencia de esta medida, no una prueba de que no existan. Tampoco aparece, dentro de un paquete, ningún tipo de chunk que no esté en esta tabla. Los chunks del nivel raíz de esas tablas son solo RES_STRING_POOL_TYPE (13.656) y RES_TABLE_PACKAGE_TYPE (13.915).

El rango 0x0100–0x017f está reservado a nodos del árbol XML: AOSP comprueba type >= RES_XML_FIRST_CHUNK_TYPE && type <= RES_XML_LAST_CHUNK_TYPE para decidir si un chunk es un nodo, así que un tipo desconocido dentro de ese rango llega a nextNode(), que lo ignora y sigue.

Cómo trata Android un chunk de tipo desconocido sale del código de AOSP, no del muestrario. En el muestrario no hay ningún caso real: ninguno de los 15.183 manifiestos ni de los 499.986 XML de res/ de la pasada de 197 piezas lleva un chunk de un tipo que no esté en la tabla.

2.3 La validación que aplica AOSP

validate_chunk() es el guardián común de los dos formatos. Rechaza un chunk si headerSize es menor que la estructura que se espera leer, si headerSize > size, si (headerSize | size) & 0x3 != 0 —ambos tamaños múltiplos de 4— o si size excede el final del bloque de datos. Es el suelo de cualquier lector correcto y la base de la «sección 7 · Manifiestos malformados: ofuscación y evasión de análisis».

3. ResStringPool: la tabla de cadenas

Segundo chunk en todo AXML que escribe aapt2 —el lector solo exige que preceda al primer nodo («sección 4.1 · RES_XML_TYPE y su contenido»)— y primero de resources.arsc. Todas las cadenas —nombres de elemento y de atributo, URIs de namespace, valores de texto— viven aquí una sola vez, y el resto del fichero las referencia por índice mediante un ResStringPool_ref, que es un uint32_t con el índice (0xFFFFFFFF significa «ninguna»).

En los AXML que escribe aapt2 el string pool va primero y el resource map («sección 6 · Cómo se resuelve el nombre de un atributo») después. Android no lo exige: acepta cualquier orden mientras los dos estén antes del primer nodo («sección 4.1 · RES_XML_TYPE y su contenido»). En el muestrario ningún AXML tiene el mapa antes del pool. Lo que sí hay son AXML sin resource map: 215 de los 500.183 que leímos en la pasada de 197 piezas (197 manifiestos y 499.986 XML de res/), todos en el mercado chino o en las apps de protectores. Los 197 manifiestos llevan mapa. Por pieza, tienen algún AXML sin mapa 11 de 100 del mercado chino y ninguna de las demás fuentes. Un ejemplo es WeRead (com.tencent.weread 10167650): 66 XML de res/ con el pool seguido directamente de los nodos.

3.1 ResStringPool_header

Campo Offset Tamaño Tipo Significado
header 0x00 8 ResChunk_header type = RES_STRING_POOL_TYPE = 0x0001
stringCount 0x08 4 uint32_t Número de cadenas
styleCount 0x0c 4 uint32_t Número de arrays de estilo
flags 0x10 4 uint32_t SORTED_FLAG = 1<<0, UTF8_FLAG = 1<<8
stringsStart 0x14 4 uint32_t Offset desde el inicio del chunk a los datos de las cadenas
stylesStart 0x18 4 uint32_t Offset desde el inicio del chunk a los datos de estilo. 0 si styleCount == 0

headerSize vale 28 (0x1c), exactamente sizeof(ResStringPool_header), en los 15.183 manifiestos del «muestrario», sin ninguna excepción. También vale 28 en los 499.986 XML de res/ y en los 197 resources.arsc de la pasada de 197 piezas. SORTED_FLAG indica que el índice está ordenado por el valor de las cadenas (strcmp16()), lo que permite búsqueda binaria; UTF8_FLAG que están en UTF-8 —en rigor, UTF-8 modificado: ver la «sección 3.3 · Codificación UTF-8 y la trampa del doble campo»— y, si falta, en UTF-16. Cuál de las dos lleva cada fichero lo decide aapt2 link: aplana el manifiesto con utf16 = true y el resto de los XML con false (Link.cpp, líneas 1923-1924 y 698-699), y con eso XmlFlattener escribe el pool con FlattenUtf16 o con FlattenUtf8 (líneas 352-356). Es lo que se ve en el manifiesto de la «sección 8.1 · Volcado del árbol y hexdump del manifiesto»: flags = 0, UTF-16.

En el muestrario aapt2 cumple casi siempre: solo 31 de 15.183 manifiestos tienen el pool en UTF-8 (flags = 0x100). Son en torno al 0,5 % de F-Droid, 2 de 100 en el mercado chino, 2 en IzzyOnDroid y 1 en Google Play. Ningún manifiesto de split va en UTF-8. De los 31, 28 son de F-Droid e IzzyOnDroid y no llevan platformBuildVersionCode ni compileSdkVersion (atributos que escribe aapt2); declaran targetSdk entre 22 y 28 y parecen de una herramienta anterior, aunque eso es una hipótesis, no una medida. Un ejemplo es ch.blinkenlights.android.vanillaplug (170, de F-Droid): manifiesto UTF-8 de 2.076 bytes, sin platformBuildVersion* y con targetSdk 27. Los otros tres son un APK de Google Play, el de Netflix para Android TV (com.netflix.ninja 13.2.1-27207, de APKMirror), y dos del mercado chino con el protector Ijiami.

SORTED_FLAG no lo hemos visto nunca: ni en los 197 manifiestos, ni en los 197 resources.arsc, ni en los 499.986 XML de res/ de la pasada de 197 piezas. En esa pasada, los XML de res/ van en UTF-8 en todos los orígenes salvo en el mercado chino, donde van 376.162 de 378.053; los otros 1.891 están en UTF-16, y 9 de las 100 piezas chinas mezclan las dos codificaciones. El pool global de resources.arsc está en UTF-8 en casi todas las piezas: 4.723 de 4.766 en F-Droid, 1.400 de 1.402 en IzzyOnDroid y todas las leídas de Google Play, del mercado chino y de las webs de los autores.

┌───────────────────────────────────────────────────────────────┐
│ ResStringPool_header              (headerSize = 28)           │
├───────────────────────────────────────────────────────────────┤
│ uint32_t offsets[stringCount]     relativos a stringsStart    │
├───────────────────────────────────────────────────────────────┤
│ uint32_t styleOffsets[styleCount] relativos a stylesStart     │
├───────────────────────────────────────────────────────────────┤
│ datos de las cadenas              (en stringsStart)           │
├───────────────────────────────────────────────────────────────┤
│ datos de estilo                   (en stylesStart)            │
└───────────────────────────────────────────────────────────────┘

3.2 Codificación UTF-16

Cada cadena empieza por su longitud en caracteres UTF-16, seguida de los datos y de un terminador 0x0000. Se lee un uint16_t; si el bit 15 está a cero, ese es la longitud; si está a uno, se lee un segundo uint16_t y la longitud es ((primero & 0x7FFF) << 16) | segundo. El máximo es 0x7FFFFFFF. AOSP rechaza la cadena si el carácter en la posición longitud no es 0x0000 («string #%d is not null-terminated»).

3.3 Codificación UTF-8 y la trampa del doble campo

Aquí está el error clásico. En un pool UTF-8 cada cadena lleva dos longitudes: primero la que tendría en caracteres UTF-16 una vez convertida, y luego la longitud en bytes UTF-8 de los datos que siguen. Cada una se codifica igual entre sí pero distinto que en UTF-16: se lee un uint8_t; si el bit 7 está a uno, se lee un segundo uint8_t y la longitud es ((primero & 0x7F) << 8) | segundo. El máximo es 0x7FFF, o sea 32.767. Detrás de los datos va un byte 00 que utf8len no cuenta, y el lector lo exige: ResStringPool::stringDecodeAt lo busca en la posición utf8len y, si no está —tras probar las longitudes mayores que 0x7FFF que aapt truncaba—, rechaza la cadena con «string #%d is not null-terminated» (ResourceTypes.cpp, líneas 999-1029). aapt2 reserva ese byte al escribir la cadena (StringPool.cpp, líneas 370-371).

Y los bytes no son UTF-8 estándar. aapt2 pasa cada cadena por Utf8ToModifiedUtf8 (libs/androidfw/Util.cpp), que codifica cada carácter fuera del BMP —un emoji, por ejemplo— como dos subrogados de tres bytes, al estilo de CESU-8, en vez de los cuatro bytes de RFC 3629. Un decodificador UTF-8 estricto falla con esas cadenas: hay que admitir los subrogados codificados, como con el MUTF-8 del DEX. Las dos longitudes siguen cuadrando: ese carácter cuenta dos unidades UTF-16 y seis bytes.

En el muestrario no hay ninguna cadena tan larga como para pasar de 0x7FFF, ni ninguna sin su 00 final. En los 15.183 manifiestos tampoco saltan las comprobaciones de cadena sin terminar ni de longitud incorrecta. La regla de AOSP sobre el terminador no se ve infringida.

Los subrogados de tres bytes sí aparecen. En el pool global de resources.arsc (el primer pool de la tabla, con el mismo formato que el de un AXML), lo llevan algunas cadenas de 15 de las 100 piezas del mercado chino y de una minoría de las demás fuentes. Los XML de res/ también (125 ficheros en el mercado chino, 93 en Google Play); en los manifiestos, ninguno. Un ejemplo: en F-Droid 2.0.2 (org.fdroid.fdroid 2000052), la cadena Congratulations 🥳 (índice 804 del pool global) empieza por sus dos longitudes, 12 16 (18 caracteres UTF-16, 22 bytes), y el emoji son estos seis bytes: ed a0 be ed b5 b3. Un decodificador UTF-8 estricto la rechaza. El pool global de ese APK tiene 40 cadenas con subrogados de tres bytes y ninguna con los cuatro bytes estándar. El UTF-8 estándar de cuatro bytes solo lo usa una de las 100 piezas del mercado chino, la de Taobao (com.taobao.taobao 863), así que un lector tiene que aceptar las dos formas.

Las dos trampas:

  • Leer una sola longitud. Funciona con cualquier cadena ASCII, porque entonces los dos valores coinciden y el lector se come el segundo byte creyéndolo el primer carácter. Con la primera cadena no ASCII se desalinea.
  • Asumir que las dos longitudes ocupan el mismo número de bytes. Cada campo decide su forma por separado.

Ambas se ven en el muestrario, y no son rarezas. En el pool global de resources.arsc, la primera trampa (utf16len distinto de utf8len) aparece en casi todas las piezas de la pasada de 197. La segunda (un campo en forma corta y el otro en larga) es algo menos común, pero sale en la mayoría de las fuentes y en las 100 piezas del mercado chino. En los manifiestos, casi todos en UTF-16, la primera solo se ve en los dos UTF-8 del mercado chino y la segunda en ninguno.

El volcador de la «sección 8.2 · Volcado de chunks propio» lo enseña sobre el pool global de F-Droid 2.0.2 (20.646 cadenas, UTF-8). Ese pool es el de resources.arsc, y usa el mismo formato que el de un AXML. Comando: python3 -I scripts/muestrario/cifras/manifiesto_1.py --volcar <resources.arsc extraído> --nivel 1 --cadenas. Dentro de él, 13.817 cadenas tienen utf16len distinto de utf8len, 453 mezclan un campo corto y otro largo, 1.116 llevan alguna longitud en forma larga y 40 tienen subrogados.

primer string con utf16len != utf8len, y corto:
  idx=735   utf16len=18  utf8len=20
  bytes = 12 14 41 64 64 69 6e 67 20 72 65 70 6f 73 69 74 6f 72 79 e2 80 a6   →  'Adding repository…'

primer string con longitud en forma larga (bit alto):
  idx=0     utf16len=657  utf8len=710
  primeros bytes = 82 91 82 c6 41 70 6c 69   →  'Aplikacionet në F-Droid…'

primer string con un campo corto y el otro largo:
  idx=2418  utf16len=121  utf8len=128
  primeros bytes = 79 80 80 49 73 20 66 c3   →  'Is féidir le F-Droid repos…'

En el primero, 0x12 = 18 caracteres UTF-16 y 0x14 = 20 bytes UTF-8: los puntos suspensivos … ocupan tres bytes (e2 80 a6) y un solo carácter. El volcado enseña 2 + 20 bytes, los dos campos y los datos que cuenta utf8len, y se detiene ahí: el 00 terminador no entra en ninguna de las dos longitudes. En el segundo, 0x82 0x91 es la forma larga de 657 (((0x82 & 0x7F) << 8) | 0x91) y 0x82 0xc6 la de 710; los dos campos están en forma larga y ocupan cuatro bytes en total. El tercero ilustra la segunda trampa: 0x79 = 121 va en un byte, pero 128 bytes ya no caben en uno, y se escriben 0x80 0x80. Un lector que dé a cada campo el mismo tamaño se desalinea.

3.4 Estilos: ResStringPool_span

Si styleCount > 0, tras los offsets de cadena viene un segundo array de uint32_t, uno por estilo, con offsets relativos a stylesStart. Cada entrada apunta a un array de ResStringPool_span terminado por el centinela 0xFFFFFFFF:

Campo Offset Tamaño Tipo Significado
name 0x00 4 ResStringPool_ref Índice en el propio pool de la etiqueta que abrió el span (b, i, u, font…), que a veces lleva además sus atributos tras un ; (ver el ejemplo). END = 0xFFFFFFFF cierra el array
firstChar 0x04 4 uint32_t Primer carácter al que se aplica, inclusive
lastChar 0x08 4 uint32_t Último carácter al que se aplica, inclusive

Los índices cuentan caracteres, no bytes, incluso en un pool UTF-8: otra razón por la que la longitud UTF-16 se guarda aparte. Los estilos se asocian a las primeras styleCount cadenas del pool. Un ejemplo, de Pachli 3.9.1 (app.pachli 56, de F-Droid), cuyo pool global de resources.arsc tiene 47.809 cadenas y 140 estilos (UTF-8, stringsStart 0x2ed50, stylesStart 0x1d0be4):

estilo del string [125] = 'Pachli是一个Nivenly Foundation项目。'
   ResStringPool_span  name=3064('a;href=https://nivenly.org')  firstChar=9  lastChar=26

El name no es solo el nombre de la etiqueta: aquí la cadena 3064 es a;href=https://nivenly.org, la etiqueta a con su atributo. Los índices cuentan caracteres: del 9 al 26 están las 18 letras de Nivenly Foundation. Un lector tiene que cortar ese texto por el primer ; si solo quiere el nombre de la etiqueta. Eso lo hemos visto en esta cadena; no lo hemos comprobado en otras apps. La cadena 0 de ese pool tiene un span más simple, name=3166('i') de 69 a 102. El pool de F-Droid 2.0.2 (org.fdroid.fdroid 2000052) tiene un solo estilo, un span em de 29 a 36 en la cadena 0.

Tener estilos en el pool global no es raro: lo tiene una de cada seis piezas de F-Droid, y en el mercado chino, dos de cada tres.

3.5 Por qué el string pool es la pieza delicada del round-trip

Si quieres reescribir un pool y obtener los mismos bytes, tienes que reproducir decisiones que el formato deja libres. Son cinco:

  • el orden de las cadenas, que no sigue ninguna regla y cuyo cambio reindexa todo el fichero;
  • la deduplicación: dos cadenas iguales pueden compartir offset o no, y en el muestrario se dan los dos casos, aunque nunca juntos en el mismo fichero;
  • la forma de la longitud: un valor de 100 se puede escribir 0x64 o, sin violar ninguna regla del lector, 0x80 0x64;
  • el relleno hasta el múltiplo de 4 que exige validate_chunk;
  • stylesStart cuando styleCount == 0, que casi siempre vale 0 (en el muestrario hay un caso que no) y que AOSP ni exige ni lee en ese caso.

Ninguna afecta a la semántica; todas afectan a los bytes. Y ninguna se reconstruye a partir de la lista de cadenas. Por eso el modelo de un lector que aspire al round-trip no puede ser un Vec<String>: tiene que guardar la codificación observada.

Esto es lo que vimos en los manifiestos de la pasada de 197 piezas:

  • Cadenas iguales que comparten offset. Es raro y está casi solo en el mercado chino: 31 de 100 manifiestos, frente a ninguno en el resto. Los 21 manifiestos chinos con el protector Bangcle/SecNeo (según APKiD) lo hacen todos. Dos ejemplos: el correo 189 (com.corp21cn.mail189 185, que además va en UTF-8) y com.cctv.caijing (2026081400, de la muestra de protectores; offsets compartidos y mapa desordenado).
  • Cadenas iguales guardadas más de una vez. Es lo normal: lo hacen casi todos los manifiestos de Google Play y de IzzyOnDroid, más de la mitad de los de F-Droid y 54 de 100 del mercado chino. Por qué hay tantas copias no lo hemos medido.
  • Las dos cosas en el mismo pool: nunca. Ni en los manifiestos, ni en los resources.arsc, ni en los XML de res/. En estos últimos, los offsets compartidos solo aparecen en 10 de las 86 piezas chinas que los tienen.
  • Longitudes en forma larga cuando cabían en la corta: ninguna. La regla las permite (el 100 como 0x80 0x64 en vez de 0x64), pero ningún pool lo hace, ni en manifiestos, ni en XML de res/, ni en resources.arsc. Un fichero que no las use así sería señal de que no lo escribió aapt2 («sección 7.5 · Huellas de quién escribió el AXML»).
  • stylesStart distinto de 0 sin estilos: un caso. El manifiesto de Netflix para Android TV (com.netflix.ninja 13.2.1-27207, el mismo UTF-8 de la «sección 3.1 · ResStringPool_header») tiene un pool de 284 cadenas con styleCount 0 y stylesStart 0x2ba0, justo el tamaño del pool. AOSP no lee el campo cuando no hay estilos, así que el fichero funciona. Leímos uno a uno los 31 manifiestos en UTF-8 y es el único (clave axml.styles_start_manifiestos_utf8 de scripts/muestrario/cifras/ejemplos_1.py, que lee de cada uno los bytes 0x20–0x23). En la pasada de 197 piezas no aparece en ningún sitio. En el resto de las 15.183 piezas no lo medimos: el medidor general no guarda stylesStart. Un lector no debe dar por hecho que vale 0.

4. El árbol XML

4.1 RES_XML_TYPE y su contenido

El chunk raíz es un ResXMLTree_header, que no añade ningún campo a ResChunk_header: 8 bytes, headerSize = 8. Dentro vienen estos chunks. El string pool y el resource map pueden intercambiarse entre sí, pero los dos van antes del primer nodo: ResXMLTree::setTo solo los busca hasta dar con él, y sin string pool rechaza el fichero.

┌──────────────────────────────────────────────────────────────────┐
│ RES_XML_TYPE           headerSize=8   size = fichero completo    │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ RES_STRING_POOL_TYPE                                         │ │
│ ├──────────────────────────────────────────────────────────────┤ │
│ │ RES_XML_RESOURCE_MAP_TYPE          (opcional)                │ │
│ ├──────────────────────────────────────────────────────────────┤ │
│ │ RES_XML_START_NAMESPACE_TYPE                                 │ │
│ │ RES_XML_START_ELEMENT_TYPE   ┐                               │ │
│ │ RES_XML_CDATA_TYPE           │ array plano: la jerarquía la  │ │
│ │ RES_XML_END_ELEMENT_TYPE     │ da el orden START/END         │ │
│ │ …                            ┘                               │ │
│ │ RES_XML_END_NAMESPACE_TYPE                                   │ │
│ └──────────────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────────┘

No hay árbol. Hay una lista de nodos, y la anidación se deduce del emparejamiento de START_ELEMENT con END_ELEMENT, como en un XmlPullParser. Nada en el formato obliga a que estén bien emparejados; ver «sección 7 · Manifiestos malformados: ofuscación y evasión de análisis».

4.2 El nodo común: ResXMLTree_node

Los cinco tipos de nodo comparten esta cabecera de 16 bytes:

Campo Offset Tamaño Tipo Significado
header 0x00 8 ResChunk_header headerSize = 16 en los nodos de los 15.183 manifiestos y en los 499.986 XML de res/ de la pasada de 197 piezas (0 excepciones)
lineNumber 0x08 4 uint32_t Línea del fichero fuente. Informativo
comment 0x0c 4 ResStringPool_ref Comentario asociado. 0xFFFFFFFF si no hay

La extensión propia de cada tipo empieza en nodo + header.headerSize, no en nodo + 16. Es la diferencia entre un lector correcto y uno que funciona por casualidad.

4.3 Las extensiones de cada tipo de nodo

ResXMLTree_namespaceExt, para los tipos 0x0100 y 0x0101. 8 bytes; chunk total 24.

Campo Offset Tamaño Tipo Significado
prefix 0x00 4 ResStringPool_ref Prefijo (android, app, aapt…; ver abajo cuáles aparecen)
uri 0x04 4 ResStringPool_ref URI (http://schemas.android.com/apk/res/android)

Estos son los prefijos que aparecen en el muestrario (pasada de 197 piezas; son recuentos de nodos de namespace de manifiestos y XML de res/, no de piezas). android está en todos los AXML con atributos del sistema (480.835 nodos). Le siguen app, para los atributos de las bibliotecas de la propia app (http://schemas.android.com/apk/res-auto, 105.325 nodos), y aapt, datos de la herramienta como los <aapt:attr> de los vectores (http://schemas.android.com/aapt, 15.761). Hay además prefijos propios de cada app (fresco, up, latin, avatar…) y 13.748 nodos sin prefijo, todos en el mercado chino (13.714 con la URI vacía). tools casi no aparece, porque aapt2 lo quita al compilar: ninguna vez con la URI oficial (http://schemas.android.com/tools). Sale 44 veces en 16 piezas con URI distintas: res-auto 17, apk/tools 14, erratas de la URI oficial 10 y otras 3. Esas URI no las sabemos explicar; pueden ser erratas o herramientas de otros compiladores. Por ejemplo, WeCom (com.tencent.wework 84257) tiene tools=http://schmas.android.com/tools y tools=http://schemas.tools; la app de banca com.cib.cibmb (184), tools=http://schemas.android.com/apk/res-auto. dist (http://schemas.android.com/apk/distribution, los módulos de funcionalidad de bundletool) apareció en un solo manifiesto, el del mando a distancia de Xiaomi com.duokan.phone.remotecontroller (6411), y amazon en otro, el del WhatsApp de la web del autor.

ResXMLTree_endElementExt, para el tipo 0x0103. 8 bytes; chunk total 24.

Campo Offset Tamaño Tipo Significado
ns 0x00 4 ResStringPool_ref Namespace del elemento que se cierra
name 0x04 4 ResStringPool_ref Nombre del elemento que se cierra

ResXMLTree_cdataExt, para el tipo 0x0104. 12 bytes; chunk total 28.

Campo Offset Tamaño Tipo Significado
data 0x00 4 ResStringPool_ref El texto en crudo
typedData 0x04 8 Res_value El mismo texto ya tipado, si se pudo

Los XML de res/ casi no llevan texto entre etiquetas, pero algunos sí. Ejemplo: el res/8G.xml de F-Droid 2.0.2 (org.fdroid.fdroid 2000052) es un fichero de configuración de red (network-security-config) de 2.068 bytes con 18 START_ELEMENT, 18 END_ELEMENT, 8 CDATA (los nombres de dominio entre etiquetas) y ningún chunk de namespace, lo que es perfectamente legal. Su pool es UTF-8 y tiene 21 cadenas.

AndroidManifest.xml casi nunca lleva CDATA (pasada de 197 piezas): ninguno de F-Droid, IzzyOnDroid, Google Play, el sorteo ni las webs de los autores, y 10 de 100 del mercado chino. El de Alipay (com.eg.android.AlipayGphone 991) lleva 16. En los XML de res/ es raro por fichero, pero lo tiene algún fichero en la mayoría de las piezas de Google Play (22 de 25) y en 72 de 86 de las chinas. En F-Droid solo 2 de 25 piezas. Ficheros sin ningún chunk de namespace hay bastantes: unos 4.700 en el mercado chino, unos 4.000 en las webs de los autores y varios cientos en cada uno de los otros orígenes.

¿Por qué 8G.xml? aapt2 optimize acorta las rutas de los recursos si se le pasa --shorten-resource-paths: el recurso se guarda con un nombre de uno o dos caracteres, sin la carpeta con calificadores. Tienen rutas acortadas del tipo res/8G.xml en torno al 85 % de las piezas de F-Droid y el 89 % de las de IzzyOnDroid, el 42 % de las del mercado chino y bastantes menos de las de Google Play (un 8 % las más instaladas, un 5 % el sorteo). Un ejemplo de IzzyOnDroid es cn.morfans.chenjunyu19.mediavolume (22).

4.4 ResXMLTree_attrExt — tipo 0x0102, START_ELEMENT

20 bytes de extensión, seguidos del array de atributos.

Campo Offset Tamaño Tipo Significado
ns 0x00 4 ResStringPool_ref Namespace del elemento. 0xFFFFFFFF si ninguno
name 0x04 4 ResStringPool_ref Nombre del elemento
attributeStart 0x08 2 uint16_t Offset desde el inicio de esta extensión al primer atributo. Vale 0x14
attributeSize 0x0a 2 uint16_t Tamaño de cada ResXMLTree_attribute. Vale 0x14
attributeCount 0x0c 2 uint16_t Número de atributos
idIndex 0x0e 2 uint16_t Índice base 1 del atributo android:id. 0 si no hay
classIndex 0x10 2 uint16_t Índice base 1 del atributo class. 0 si no hay
styleIndex 0x12 2 uint16_t Índice base 1 del atributo style. 0 si no hay

El atributo i está en extensión + attributeStart + attributeSize * i. Los dos campos deben leerse del fichero, no darse por supuestos: son precisamente los que manipula la ofuscación de manifiestos («sección 7.3 · Técnicas observadas en la literatura»). Y ni siquiera aapt2 escribe siempre 0x14. En android-17.0.0_r1, si el elemento depende de un flag de lectura/escritura, mete entre la extensión y los atributos un ResXMLTreeFlagExt de 8 bytes —descriptor (FLAG_INFO = 0x01), flag_negated, 2 bytes reservados y el nombre del flag como ResStringPool_ref— y attributeStart pasa a valer 0x1c. El sistema solo lo interpreta con el flag de plataforma layout_readwrite_flags activo, que no es el resource_readwrite_flags del que dependen los chunks 0x0207 y 0x0208 de resources.arsc («sección 12.5 de Tabla de recursos · RES_TABLE_FLAGGED (0x0207) y RES_TABLE_FLAG_LIST (0x0208)»).

En el muestrario attributeStart y attributeSize valen siempre 0x14: ninguna excepción en los 15.183 manifiestos ni en los 499.986 XML de res/ de la pasada de 197 piezas. Ningún APK está compilado todavía con el aapt2 de Android 17 que añade el bloque de 8 bytes de flags: attributeStart no vale 0x1c en ninguno. Es un dato de existencia a octubre de 2026; hay que leer los dos campos del fichero igualmente.

4.5 ResXMLTree_attribute

20 bytes, y son los 20 bytes que más se leen de todo el APK.

Campo Offset Tamaño Tipo Significado
ns 0x00 4 ResStringPool_ref Namespace del atributo. 0xFFFFFFFF si ninguno
name 0x04 4 ResStringPool_ref Índice en el string pool, no un resource ID. Ver «sección 6 · Cómo se resuelve el nombre de un atributo»
rawValue 0x08 4 ResStringPool_ref Valor textual original. 0xFFFFFFFF si aapt2 no lo conservó
typedValue 0x0c 8 Res_value El valor ya tipado

aapt2 conserva rawValue cuando el valor es una cadena; para un entero o un booleano vale 0xFFFFFFFF. Por eso aapt2 dump xmltree imprime (Raw: "…") solo en algunos atributos.

Hay excepciones. En la pasada de 197 piezas, 1 de 25 manifiestos de F-Droid y 3 de 100 del mercado chino guardan también el texto original de valores que no son cadenas; en IzzyOnDroid, Google Play, el sorteo y las webs de los autores, ninguno. Ejemplos: ru.zxalexis.ugaday (15, de F-Droid) y el Dou Dizhu de Tencent (com.qqgame.hlddz 1571). En los XML de res/, lo hacen 2 ficheros de F-Droid y 441 del mercado chino. No hemos visto el caso contrario: ningún atributo de tipo cadena sin rawValue. No hemos mirado qué herramienta produce cada caso. Es otra huella de escritor («sección 7.5 · Huellas de quién escribió el AXML»).

5. Res_value

Los 8 bytes que representan cualquier valor tipado. Aparecen en AXML (en cada atributo y cada CDATA) y en resources.arsc: son el punto de contacto entre los dos formatos.

Campo Offset Tamaño Tipo Significado
size 0x00 2 uint16_t Tamaño de la estructura. Vale 8, con las excepciones de abajo
res0 0x02 1 uint8_t Reservado. Siempre 0
dataType 0x03 1 uint8_t Tipo del dato
data 0x04 4 uint32_t El dato, interpretado según dataType

size vale 8 en casi todos los valores, pero no en todos (pasada de 197 piezas). En los manifiestos, 2 de 100 piezas del mercado chino tienen algún valor con otro tamaño, y ninguna de las demás fuentes. Los dos casos son las dos apps de TikTok/Douyin: com.ss.android.ugc.aweme (400801) guarda size = 0 en 1.471 de sus 9.139 atributos, y com.ss.android.ugc.aweme.lite (400901) en 1.360 de 8.318. En resources.arsc, 4 de 100 piezas chinas llevan un valor con size = 3, por ejemplo la app de KFC com.yek.android.kfc.activitys (63700); ninguna de las otras fuentes. En los 499.986 XML de res/, ningún caso. El campo res0 vale 0 en todos los valores leídos. Quien lea esta estructura no debe fiarse de size para saltar ni para comprobar.

5.1 Los TYPE_*

Nombre Valor data contiene
TYPE_NULL 0x00 0 = DATA_NULL_UNDEFINED, 1 = DATA_NULL_EMPTY
TYPE_REFERENCE 0x01 Un resource ID (0xPPTTEEEE)
TYPE_ATTRIBUTE 0x02 El resource ID de un atributo (?attr/…)
TYPE_STRING 0x03 Índice en el string pool del contenedor
TYPE_FLOAT 0x04 Un float IEEE-754 de precisión simple, reinterpretado
TYPE_DIMENSION 0x05 Número complejo; ver 5.2
TYPE_FRACTION 0x06 Número complejo; ver 5.2
TYPE_DYNAMIC_REFERENCE 0x07 Referencia cuyo PP debe traducirse en tiempo de ejecución
TYPE_DYNAMIC_ATTRIBUTE 0x08 Ídem para atributos
TYPE_FIRST_INT = TYPE_INT_DEC 0x10 Entero, escrito en decimal en el fuente
TYPE_INT_HEX 0x11 Entero, escrito en hexadecimal en el fuente
TYPE_INT_BOOLEAN 0x12 0 = false, distinto de 0 = true
TYPE_FIRST_COLOR_INT = TYPE_INT_COLOR_ARGB8 0x1c #aarrggbb
TYPE_INT_COLOR_RGB8 0x1d #rrggbb
TYPE_INT_COLOR_ARGB4 0x1e #argb
TYPE_INT_COLOR_RGB4 = TYPE_LAST_COLOR_INT = TYPE_LAST_INT 0x1f #rgb

La distinción entre 0x10 y 0x11, y entre las cuatro variantes de color, solo existe para poder reimprimir el valor como se escribió. El sistema los trata igual. Un reconstructor a texto que ignore dataType produce XML válido pero distinto del original.

Un booleano ocupa un valor de tipo TYPE_INT_BOOLEAN (0x12) cuyo dato es 0xffffffff para true y 0 para false. El manifiesto de Termux lleva <application> en +0x2344, con extractNativeLibs en 0xffffffff (true) y allowBackup en 0 (false):

  #   name (pool)                    resmap     dataType data
  4   'allowBackup'                  0x01010280 0x12     0x00000000
  7   'extractNativeLibs'            0x010104ea 0x12     0xffffffff
 10   'requestLegacyExternalStorage' 0x01010603 0x12     0xffffffff

extractNativeLibs decide si Android copia las .so al instalar. Entre las apps que llevan alguna .so en lib/, lo habitual en F-Droid, IzzyOnDroid y el sorteo de Google Play es declarar false (cerca de dos de cada tres: 1.863 de 2.709 en F-Droid). En Google Play (las más instaladas) está más repartido, con 344 false y 253 true de 615. En el mercado chino es al revés: 59 true y solo 4 false de 100, y 37 no lo declaran. Sin declarar lo dejan en torno al 9 % en F-Droid e IzzyOnDroid y muy pocas en Google Play.

Su detalle está en «Código nativo y ELF». pageSizeCompat es un entero de <application> que casi nadie declara: lo hacen 19 apps en todo el muestrario, 18 con el valor 32 y una (de Google Play) con 64. En 4 de ellas (2 de F-Droid y 2 de IzzyOnDroid) no hay ninguna .so ELF en lib/arm64-v8a/; por ejemplo com.android.gpstest.osmdroid (24100) y com.rosan.dhizuku (17), ambas de F-Droid.

5.2 Números complejos: COMPLEX_*

TYPE_DIMENSION y TYPE_FRACTION empaquetan mantisa, radix y unidad en los 32 bits de data:

 31                                8   7 6        5 4         3 2 1 0
┌────────────────────────────────────┬─────┬──────────────┬─────────────┐
│ mantisa con signo (24 bits)        │ --- │     radix    │     unit    │
└────────────────────────────────────┴─────┴──────────────┴─────────────┘
  MANTISSA_SHIFT = 8                        RADIX_SHIFT=4  UNIT_SHIFT=0
  MANTISSA_MASK = 0xffffff                  MASK = 0x3     MASK = 0xf
Constante Valor Significado
COMPLEX_UNIT_PX 0 TYPE_DIMENSION: píxeles
COMPLEX_UNIT_DIP 1 dp
COMPLEX_UNIT_SP 2 sp
COMPLEX_UNIT_PT 3 puntos
COMPLEX_UNIT_IN 4 pulgadas
COMPLEX_UNIT_MM 5 milímetros
COMPLEX_UNIT_FRACTION 0 TYPE_FRACTION: fracción del tamaño propio (%)
COMPLEX_UNIT_FRACTION_PARENT 1 Fracción del tamaño del padre (%p)
COMPLEX_RADIX_23p0 0 Mantisa entera, 0xnnnnnn.0
COMPLEX_RADIX_16p7 1 0xnnnn.nn
COMPLEX_RADIX_8p15 2 0xnn.nnnn
COMPLEX_RADIX_0p23 3 0x0.nnnnnn

El valor real es mantisa * 2^(-tabla[radix]) con tabla = {0, 7, 15, 23}, multiplicado después por el factor de la unidad. Los bits 6 y 7 no están asignados por ningún enum de ResourceTypes.h (líneas 357-401 en android-17.0.0_r1), y ni se escriben ni se leen: ResTable::stringToFloat, que es lo que usa aapt2 para compilar una dimensión, solo compone unidad, radix y mantisa (ResourceTypes.cpp, líneas 5503 y 5707-5709), y TypedValue.complexToFloat enmascara el radix con COMPLEX_RADIX_MASK = 0x3 y los descarta. En la pasada de 197 piezas leímos 3.633.034 valores complejos en 192 APK: 2.649.756 en atributos de AXML (manifiestos y XML de res/) y 983.278 en resources.arsc (entradas simples, mapas y compactas). Ninguno tiene los bits 6 y 7 a uno. Con las cinco piezas de protectores, que suman 84.039 valores más en AXML y 31.564 en resources.arsc, tampoco. En los AXML solo cuentan los atributos: los typedData de los CDATA no. Casi todas las piezas tienen algún valor complejo en sus XML de res/, pero en los manifiestos son raros: 5 de 100 en el mercado chino, 1 de 25 en Google Play, 1 de 20 en el sorteo y ninguno en F-Droid ni IzzyOnDroid. El muestrario entero se describe en «El muestrario». Nada impide que un fichero manipulado los ponga a uno; un lector debe ignorarlos, como hace el sistema.

6. Cómo se resuelve el nombre de un atributo

Este es el punto que más confunde.

El campo name de ResXMLTree_attribute es un índice en el string pool, no un resource ID. Para android:versionCode la cadena guardada es simplemente "versionCode", sin prefijo, y el nombre es ambiguo: podría ser el atributo del framework 0x0101021b o uno propio de la aplicación que se llame igual. La desambiguación no está en la cadena: está en el resource map chunk.

6.1 El mecanismo

RES_XML_RESOURCE_MAP_TYPE (0x0180) es un chunk cuya carga útil es un array plano de uint32_t de longitud (size - headerSize) / 4. La regla es:

El elemento i del array es el resource ID de la cadena i del string pool.

El array es paralelo al principio del string pool. Si un atributo referencia la cadena de índice 6 y el resource map tiene al menos 7 entradas, su resource ID es resIds[6]. Si el índice cae fuera del array, el atributo no tiene resource ID: es uno de los que no son recurso de nadie, como package, split o los platformBuildVersionCode y platformBuildVersionName que añade aapt2. Los atributos propios de la aplicación que sí tienen ID —los app: de un layout, con su 0x7f…— están en el mapa como los del framework. Literalmente, de ResXMLParser::getAttributeNameResID:

int32_t id = getAttributeNameID(idx);
if (id >= 0 && (size_t)id < mTree.mNumResIds) {
    uint32_t resId = dtohl(mTree.mResIds[id]);
    …
    return resId;
}
return 0;

Dos consecuencias. Primera: las primeras N cadenas del pool de un manifiesto no son arbitrarias; son los nombres de los atributos del framework que el fichero usa, en el mismo orden que el resource map. Reordenar el pool sin reordenar el resource map rompe el fichero. Segunda: el resource ID es la autoridad, no el nombre.

Lo que se ve en el muestrario. Las primeras cadenas del pool de un manifiesto son, en efecto, los nombres de los atributos del sistema que el fichero usa, en el orden del mapa. En Termux el mapa tiene 39 entradas y las cadenas de la 0 a la 38 son theme, label, icon… requestLegacyExternalStorage («sección 6.2 · Un ejemplo real, byte a byte»). En la pasada de 197 piezas, ningún atributo del espacio android queda sin ID, ni en los manifiestos ni en los 499.986 XML de res/. Es una comprobación de existencia: no prueba que cada ID sea el correcto, y no hemos comparado cada uno con la lista pública de atributos (public.xml).

aapt2 añade al <manifest> los atributos platformBuildVersionCode y platformBuildVersionName, junto con compileSdkVersion y compileSdkVersionCodename, y casi todos los manifiestos del muestrario los llevan (manifiesto de la pieza base o única). platformBuildVersionCode está en el 98 % de las apps de F-Droid, el 99 % de las de IzzyOnDroid, el 99,8 % de las de Google Play (las más instaladas) y en todas las del sorteo y del mercado chino. compileSdkVersion está en el 95 % de las de F-Droid, el 98 % de IzzyOnDroid, el 99,5 % de Google Play y en todas las del sorteo y del mercado chino. No llevan ninguno de los dos 114 de las 4.766 de F-Droid (en torno al 2 %) y 14 de las 1.402 de IzzyOnDroid; en las demás fuentes, prácticamente ninguna. Los 28 manifiestos de F-Droid e IzzyOnDroid que van en UTF-8 («sección 3.1 · ResStringPool_header») están todos en ese grupo. Parecen de apps compiladas con herramientas anteriores, pero es una hipótesis (su targetSdk es 28 o menos), no una medida; no hemos buscado la causa de los 114 de F-Droid.

Casi todos los atributos de un AXML son del sistema (paquete 0x01) o de la app (paquete 0x7f). Los IDs de otros paquetes salen en apps que fusionan módulos de funcionalidad (pasada de 197 piezas). El base.apk de Shopee (com.shopee.id 3.83.36, de APKMirror) declara tres paquetes más en el mapa de sus XML de res/, con IDs 0x7c (26 IDs), 0x6b (11) y 0x6a (7), y sus valores de referencia apuntan además a 0x64. El manifiesto de com.android.bankabc (102, del mercado chino) referencia recursos de los paquetes 0x4c y 0x29 y su resources.arsc declara 24 paquetes. Las referencias dinámicas (TYPE_DYNAMIC_REFERENCE y TYPE_DYNAMIC_ATTRIBUTE) no aparecen en ninguna de las 197 piezas: ni en manifiestos, ni en XML de res/, ni en resources.arsc. La tabla de la «sección 5.1 · Los TYPE_*» las describe, pero el muestrario no tiene un ejemplo real. En los resources.arsc de las 15.183 piezas (13.656 con tabla), 129 piezas tienen más de un paquete, 223 tienen algún paquete con ID menor que 0x7f (casi todas de Google Play) y 116 alguno mayor, y 340 llevan un chunk RES_TABLE_LIBRARY_TYPE. Por apps, declaran más de un paquete en su base 24 de 658 de Google Play (las más instaladas) y casi ninguna de las demás fuentes. Las referencias dinámicas las contamos solo en las 197 piezas, no en las 15.183.

6.2 Un ejemplo real, byte a byte

Sobre Termux (com.termux 1022, versión 0.119.0-beta.3, de F-Droid). El chunk del resource map está en +0x1a80:

00001a80: 8001 0800 a400 0000 0000 0101 0100 0101  ................
00001a90: 0200 0101 0300 0101 0600 0101 0900 0101  ................

type = 0x0180, headerSize = 0x0008, size = 0x000000a4 = 164. El array tiene (164 - 8) / 4 = 39 entradas: 0x01010000, 0x01010001, 0x01010002… Y el principio del string pool, en paralelo:

Índice Resource map Cadena del pool
0 0x01010000 theme
1 0x01010001 label
2 0x01010002 icon
3 0x01010003 name
6 0x0101000b sharedUserId
20 0x0101021b versionCode
35 0x01010572 compileSdkVersion
37 0x0101057a appComponentFactory
38 0x01010603 requestLegacyExternalStorage

Los resource IDs van en orden creciente, que es como aapt2 los emite; de la cadena 39 en adelante ya no hay cobertura. El elemento <manifest> está en +0x1b3c:

00001b3c: 0201 1000 ec00 0000 0200 0000 ffff ffff  ................
00001b4c: ffff ffff 7000 0000 1400 1400 0a00 0000  ....p...........
00001b5c: 0000 0000 6d00 0000 0600 0000 5600 0000  ....m.......V...
00001b6c: 0800 0003 5600 0000 6d00 0000 1400 0000  ....V...m.......

type = 0x0102, headerSize = 16, size = 0xec = 236, lineNumber = 2, comment = 0xFFFFFFFF. La extensión empieza en +0x1b4c: ns = 0xFFFFFFFF, name = 0x70 = 112 ("manifest"), attributeStart = 0x14, attributeSize = 0x14, attributeCount = 10. Y 16 + 20 + 20 × 10 = 236, que es exactamente size.

El primer atributo empieza en 0x1b4c + 0x14 = 0x1b60: ns = 109 (el URI de android), name = 6, rawValue = 86, typedValue = {size:8, res0:0, dataType:0x03, data:86}. Se resuelve resIds[6] = 0x0101000b = android:sharedUserId, de tipo TYPE_STRING apuntando a la cadena 86, "com.termux". Que es justo lo que imprime aapt2 en la receta 8.1.

Los diez atributos, resueltos con el volcador de la «sección 8.2 · Volcado de chunks propio»:

  #   name (pool)                  resmap     dataType data
  0   'sharedUserId'               0x0101000b 0x03     0x00000056  raw='com.termux'
  1   'versionCode'                0x0101021b 0x10     0x000003fe  raw=—
  2   'versionName'                0x0101021c 0x03     0x00000027  raw='0.119.0-beta.3'
  3   'sharedUserLabel'            0x01010261 0x01     0x7f1000d9  raw=—
  4   'installLocation'            0x010102b7 0x10     0x00000001  raw=—
  5   'compileSdkVersion'          0x01010572 0x10     0x0000001e  raw=—
  6   'compileSdkVersionCodename'  0x01010573 0x03     0x00000028  raw='11'
  7   'package'                    —          0x03     0x00000056  raw='com.termux'
  8   'platformBuildVersionCode'   —          0x10     0x0000001e  raw=—
  9   'platformBuildVersionName'   —          0x10     0x0000000b  raw=—

Los tres últimos no tienen resource ID: sus índices caen fuera de las 39 entradas. El atributo 3 tiene dataType = 0x01 (TYPE_REFERENCE) y data = 0x7f1000d9, un resource ID del paquete de la aplicación: para saber qué texto es hay que ir a resources.arsc. Los dos formatos no se entienden por separado.

El orden creciente del mapa no se cumple siempre. En la pasada de 197 piezas tienen el mapa desordenado 47 de los 100 manifiestos del mercado chino, 1 de 25 de F-Droid y 1 de 16 de IzzyOnDroid, y ninguno de Google Play, del sorteo ni de las webs de los autores. En los XML de res/, 9 de las 86 piezas chinas con XML y 1 de 25 de F-Droid (en total, 3.355 ficheros chinos y 2 de F-Droid). Es una huella de que otra herramienta reescribió el fichero: los 21 manifiestos chinos con Bangcle/SecNeo (según APKiD) la tienen. Pero no basta para reconocer un protector: 13 de las 58 apps chinas en las que APKiD no ve ningún protector también la tienen. Es una inferencia; lo medido es la frecuencia. Ejemplos: ru.zxalexis.ugaday (15, de F-Droid) y com.leaf.explorer (142, de IzzyOnDroid).

6.3 Consecuencia para quien edita

Añadir una cadena al pool obliga a reindexar todos los nodos, todos los atributos y —si entra antes de la posición 39 del ejemplo— también el resource map. Añadirla al final lo evita, y vale para cadenas de valor. Pero no para el nombre de un atributo del framework: al final del pool queda fuera del resource map, el atributo se queda sin ID y el sistema lo ignora sin avisar —un android:debuggable añadido así no hace nada—. El nombre tiene que caer dentro del tramo que cubre el mapa, reutilizando la cadena si ya está o insertándola ahí y ampliando el mapa. Y el atributo tiene que entrar en su elemento en orden de resource ID: RetrieveAttributes (libs/androidfw/AttributeResolution.cpp) recorre los atributos del XML en paralelo con los que pide el sistema y da ese orden por hecho, así que uno desordenado se pierde. Eso vale para los atributos con resource ID que el sistema lee por styleable, con obtainAttributes. Los que se leen por nombre no dependen del orden: getAttributeValue(ns, name) de XmlBlock llega a ResXMLParser::indexOfAttribute, que recorre los atributos del elemento uno a uno, y así lee ApkLiteParseUtils el atributo package del manifiesto.

La regla del orden no es solo teoría. En la pasada de 197 piezas, 5 de 100 manifiestos del mercado chino tienen elementos con los atributos fuera de orden de resource ID (11 elementos en total), y ninguno de las demás fuentes; en los 499.986 XML de res/, ninguno. En com.tencent.tmgp.cod (3153), tres elementos <service> llevan android:enabled (0x0101000e) detrás de android:process (0x01010011). Otro ejemplo es com.tencent.fifamobile (230), con 3 elementos desordenados. Lo que le pasaría a ese atributo en Android sale de leer AOSP; no hemos instalado ninguna de estas apps.

6.4 Los manifiestos de un APK dividido (splits)

Cuando Google Play reparte una app en un APK base y varios split_*.apk, cada pieza lleva su propio manifiesto, muy pequeño: la mediana mide unos 1.050 bytes. Los atributos nuevos son split (el nombre de la pieza), configForSplit (de qué módulo es la configuración), isFeatureSplit (en los módulos de funcionalidad), requiredSplitTypes y splitTypes (qué tipos de split necesita la base). La base de una app con splits es la única pieza sin atributo split: se cumple en las 454 apps de Google Play y en las 319 del sorteo con splits. Los 7.846 splits de configuración llevan hasCode="false". El detalle, con el resto de las cifras, está en «AAB, splits y contenedores». Las cifras de esta sección salen de python3 -I scripts/muestrario/cifras/zip_y_contenedores_4.py.

7. Manifiestos malformados: ofuscación y evasión de análisis

Un AXML puede ser rechazado por aapt2, apktool y jadx y seguir instalándose. Esa asimetría es una técnica de evasión documentada y presente en familias de malware reales. El muestrario es de aplicaciones legítimas y no contiene ninguna muestra malformada en el sentido de la tabla 7.3. Ninguno de los 15.183 manifiestos infringe las 27 comprobaciones de formato que aplicamos (las de la tabla 7.2 y las técnicas de 7.3), tampoco los de las apps con protector («sección 7.6 · Qué hacen los protectores con el manifiesto»).

Sí hay rarezas que no son malformaciones, casi todas en el mercado chino: manifiestos en UTF-8, resource map desordenado, cadenas compartidas, atributos fuera de orden, valores con size = 0, un stylesStart distinto de 0 y AXML sin resource map. La «sección 7.5 · Huellas de quién escribió el AXML» las cuenta. Lo que sigue procede de AOSP y de literatura publicada y está marcado como tal.

Con las herramientas, sobre la submuestra de 117 piezas base, apksigner verifica las 113 piezas sin protectores. apktool d falla en una: el Douyin Lite (com.ss.android.ugc.aweme.lite 400901), con una NullPointerException. Es una de las dos apps con size = 0, pero no hemos demostrado que sea la causa.

7.1 De dónde nace la asimetría

El parser del sistema es permisivo por diseño. ResXMLTree::setTo —en android-17.0.0_r1, la función init a la que llama— recorre los chunks de nivel superior y, para cualquier tipo que no sea string pool, resource map o nodo XML, hace literalmente Skipping unknown chunk! y sigue. ResXMLParser::nextNode hace lo mismo con los tipos de nodo desconocidos: continue. Una herramienta que aborte donde el sistema continúa se queda sin datos que el dispositivo sí verá.

7.2 Lo que AOSP sí rechaza

La lista completa, con el mensaje literal y la línea de ResourceTypes.cpp en android-17.0.0_r1, está en la «sección 8 de Qué rechaza cada lector · ResXMLTree: el XML binario». Aquí quedan las condiciones que necesitan las secciones «4.1» y «7.3»; la cuarta no rechaza el fichero, solo deja sin valor esa cadena:

Condición Reacción de AOSP
headerSize > size BAD_TYPE
size del chunk raíz mayor que el fichero BAD_TYPE
stringCount * 4 + headerSize > size del pool BAD_TYPE, pool entero descartado
Cadena concreta no terminada en 0x0000 Esa cadena devuelve nulo; el resto sigue
En START_ELEMENT, attributeSize < 0x14 BAD_TYPE
En START_ELEMENT, attributeStart + attributeSize * attributeCount > size - headerSize BAD_TYPE
No hay string pool antes del primer nodo NO_INIT, fichero rechazado

Todo lo que no está en la lista completa pasa.

7.3 Técnicas observadas en la literatura

Técnica Campo manipulado Efecto en el analizador Qué hace Android En el muestrario
Magia alterada type del chunk raíz, 0x0003 → otro Herramientas que validan el tipo rechazan el fichero Depende de la versión: ver 7.4 Ninguna de 15.183
stringCount inflado ResStringPool_header.stringCount Lecturas fuera del array de offsets, y en algunas herramientas fuera del fichero Rechaza si desborda size; si cabe, las cadenas sobrantes salen basura y el fichero se lee Ninguna
Offsets duplicados o fuera de rango array de offsets del pool Cadenas irresolubles, bucles, caídas La cadena concreta devuelve nulo; el resto sigue Fuera de rango: ninguna. Offsets compartidos: 31 de 100 manifiestos chinos y ninguno en el resto; son cadenas compartidas válidas, no una manipulación demostrada
headerSize mentiroso en START_ELEMENT ResChunk_header.headerSize El analizador lee la extensión en el sitio equivocado Lee en nodo + headerSize, que es lo que el atacante quiso Ninguna, ni en manifiestos ni en XML de res/
Datos basura entre nodos ResChunk_header.size inflado Herramientas que avanzan por sizeof se desalinean Avanza por size y salta la basura Ninguna
attributeSize distinto de 0x14 ResXMLTree_attrExt.attributeSize Herramientas que asumen 20 bytes leen atributos desplazados Usa el campo y lee bien si es mayor; si es menor, BAD_TYPE en android-17.0.0_r1 Ninguna, ni en manifiestos ni en XML de res/
attributeStart arbitrario ResXMLTree_attrExt.attributeStart Ídem Ídem Ninguna, ni en manifiestos ni en XML de res/
Chunk de tamaño cero ResChunk_header.size = 0 Bucle infinito en cualquier lector que haga off += size sin comprobar validate_chunk lo rechaza: size < headerSize Ninguna
Namespaces sin cerrar, END_ELEMENT de más ninguno; el orden de los nodos Los reconstructores a texto producen XML no balanceado o abortan El parser es de eventos: no comprueba emparejamiento Ninguna
Bytes de cola tras el chunk raíz ninguno: bytes añadidos detrás de los size bytes del RES_XML_TYPE No verificado: un lector que recorra chunks hasta el final del fichero, y no hasta size, toma la cola por más chunks La ignora: ResXMLTree::init fija mDataEnd = header + size y solo rechaza un size mayor que los datos Ninguna, ni en manifiestos ni en XML de res/

La última fila no viene de la literatura: sale de leer ResXMLTree::init en android-17.0.0_r1 (ResourceTypes.cpp, líneas 1911-1926); no la hemos reproducido. Ningún manifiesto del muestrario tiene cola, así que no hay un ejemplo real que reproducir.

La columna «En el muestrario» cuenta manifiestos (sobre las 15.183 piezas) y, donde se dice, los XML de res/ de la pasada de 197 piezas. Ninguna técnica aparece en ningún origen, y tampoco en las cinco piezas de protectores. En los XML de res/ también dan cero las cuatro filas comprobables en ellos (headerSize de nodo, attributeSize, attributeStart y cola) y el tipo de chunk desconocido. Lo que sí se ve y la tabla no recoge: atributos fuera de orden (5 de 100 manifiestos chinos, «sección 6.3 · Consecuencia para quien edita») y Res_value con size = 0 (2 de 100 chinos, «sección 5 · Res_value»). Cada fila corresponde a una de las 27 comprobaciones del medidor (scripts/muestrario/cifras/manifiesto_1.py, que aplica también manifiesto_2.py a los tamaños declarados).

Las cuatro filas centrales comparten forma: el campo existe en el formato, el atacante lo usa como el formato manda, y quien se rompe es el analizador que dio por supuesto un valor constante. No es corrupción: es leer la especificación con más cuidado que el defensor.

7.4 El caso de la magia, con fecha

La afirmación «Android no valida el tipo del chunk raíz» circula en artículos de análisis de malware. Es cierta hasta android-14.0.0_r28 e incorrecta desde android-14.0.0_r29 (AP1A.240305.019.A1), una actualización de Android 14: no hubo que esperar a Android 15. Lo verificamos descargando libs/androidfw/ResourceTypes.cpp de nueve etiquetas de AOSP y buscando la comprobación en ResXMLTree::setTo —en android-17.0.0_r1, en ResXMLTree::init—:

Etiqueta de AOSP ¿Existe type != RES_XML_TYPE?
android-7.1.2_r36, android-11.0.0_r1, android-12.0.0_r1 No
android-13.0.0_r1, android-14.0.0_r1, android-14.0.0_r28 No
android-14.0.0_r29 Sí
android-15.0.0_r1 Sí
android-17.0.0_r1 (25 de septiembre de 2026) Sí

Un lector de terceros tiene que decidir qué versión de Android imita. Lo prudente es leer lo que el dispositivo más permisivo aceptaría y decirlo en el informe.

Ninguna de las técnicas de 7.3 la hemos visto en una muestra real, porque el muestrario no contiene malware. Sí las reproducimos sobre el AndroidManifest.xml de una muestra legítima, Shelter (net.typeblog.shelter 445, de F-Droid; manifiesto de 16.324 bytes), modificado para cada técnica y leído con aapt2 2.20-15087165 (build-tools 37.0.0) —que usa el mismo ResXMLTree de libandroidfw que el sistema—, apktool 3.0.3 y jadx 1.5.6:

Técnica aapt2 (libandroidfw) apktool 3.0.3 jadx 1.5.6
Magia 0x0003 → 0x0000 Rechaza Aborta Lee bien
stringCount + 8, dentro de size Lee bien Lee bien Lee bien
Offset fuera de rango (valor de versionName) Esa cadena sale vacía; el resto, bien Aborta Aborta
headerSize 0x18 en START_ELEMENT Lee bien Aborta Aborta
16 bytes de basura tras un nodo Lee bien Lee bien Lee bien
attributeSize 0x18 Lee bien Lee bien Lee bien
attributeSize 0x10 BAD_TYPE, y aapt2 se cae Lee bien: ignora el campo Aborta
attributeStart 0x1C Lee bien Lee bien Aborta
Nodo con size 0 Se detiene ahí, con un aviso y código 0: 10 de 223 líneas Aborta Aborta
END_ELEMENT de más Aborta, pero lo comprueba el DOM de aapt2, no ResXMLParser Aborta XML no balanceado

Cuando jadx aborta, escribe «Error decode manifest» en lugar del manifiesto y termina con código 0. La columna «qué hace Android» de 7.3 y la tabla de 7.2 siguen verificadas leyendo código, no instalando en un dispositivo. La columna «efecto en el analizador» resume lo que describen las fuentes 5 y 6. Lo que hacen de verdad aapt2 —y con él libandroidfw—, apktool 3.0.3 y jadx 1.5.6 ante las técnicas que reproduce la tabla anterior tiene como fuente primaria esta reproducción (fuente 15), y con estas versiones esa columna no se cumple en todas las filas: apktool y jadx respetan un attributeSize mayor que 0x14, jadx no valida la magia y ninguno de los dos entra en bucle con un chunk de tamaño cero.

No hemos repetido esta reproducción con el muestrario de octubre de 2026. Sí hemos comprobado tres cosas: que el fichero es el mismo que en el muestrario anterior, que las versiones de las herramientas son las del documento (aapt2 2.20-15087165, apktool 3.0.3, jadx 1.5.6), y que aapt2 dump xmltree --file AndroidManifest.xml del manifiesto intacto sigue dando 223 líneas, el denominador de «10 de 223 líneas». El script que modifica el manifiesto no se publica.

7.5 Huellas de quién escribió el AXML

aapt2 es muy regular: el manifiesto va en UTF-16, el resource map va en orden creciente, cada cadena se guarda una sola vez, los atributos de un elemento van en orden de resource ID, cada valor mide 8 bytes y el texto original (rawValue) solo se conserva en las cadenas. Un fichero que rompe una de estas reglas no está mal formado: lo ha escrito, o reescrito, otra herramienta.

En el muestrario esas rarezas son raras fuera del mercado chino. Estas son las que hemos contado, en la pasada de 197 piezas salvo donde se dice otra cosa:

  • Manifiesto en UTF-8: 2 de 100 chinas (y 31 de 15.183 en todo el muestrario, «sección 3.1 · ResStringPool_header»).
  • Resource map desordenado en el manifiesto: 47 de 100 chinas, 1 de 25 de F-Droid, 1 de 16 de IzzyOnDroid.
  • Offsets compartidos: 31 de 100 chinas.
  • Atributos fuera de orden: 5 de 100 chinas.
  • Res_value con size distinto de 8: en el manifiesto, 2 de 100 chinas; en resources.arsc, 4 de 100 chinas.
  • rawValue en un valor que no es cadena: 1 de 25 de F-Droid, 3 de 100 chinas.
  • Namespace sin prefijo ni URI: 1 de 100 chinas.
  • Algún AXML sin resource map: 11 de 100 chinas. Res XML en UTF-8 y en UTF-16 a la vez: 9 de 100 chinas. Algún .xml compilado fuera de res/ y assets/: 15 de 100 chinas.
  • Sin platformBuildVersion* ni compileSdkVersion (las 15.183 piezas): 114 de 4.766 apps de F-Droid y 14 de 1.402 de IzzyOnDroid.

En F-Droid, IzzyOnDroid y Google Play casi no aparecen. Ninguna huella basta por sí sola: 13 de las 58 apps chinas en las que APKiD no ve ningún protector también tienen el mapa desordenado. Un rasgo no prueba que otra herramienta lo escribiera; lo medido es la frecuencia. Entre los marcos multiplataforma, solo Flutter da algún caso de manifiesto en UTF-8 o con alguna anomalía (1 de 509 apps en F-Droid, 2 de 17 en el mercado chino). El de F-Droid es probablemente culpa de la herramienta que compiló esa app, no del marco: es un manifiesto UTF-8 de una app sin platformBuildVersion*. Jetpack Compose, React Native, Unity, Kotlin Multiplatform, Capacitor, Go, SDL, libGDX y Godot no dan ningún caso en ningún origen.

7.6 Qué hacen los protectores con el manifiesto

Un protector (por ejemplo Bangcle/SecNeo o Ijiami) suele cambiar la clase Application del manifiesto para que arranque primero su propio código. En 21 de las 26 apps de Bangcle/SecNeo es com.secneo.apkwrapper.AW, y en las 7 de Ijiami, s.h.e.l.l.S. No toda app con protector lo hace: en DexGuard, por ejemplo, el android:name no siempre apunta a una clase del protector. Dos de las 7 apps de Ijiami guardan además el manifiesto en UTF-8.

Lo que los protectores no hacen es romper el formato. Una app tiene protector si APKiD 3.1.0 marca alguna de sus piezas con una familia. APKiD midió enteras 98 de las 100 apps chinas, 653 de 658 de Google Play (las más instaladas) y 367 de 369 del sorteo. Tienen protector 46 apps de Google Play, 40 del mercado chino y 2 del sorteo, además de las cinco elegidas a propósito. Ningún manifiesto de esas apps infringe las comprobaciones de formato de 7.2 y 7.3. Para la lista de familias, véase «Empaquetadores y protectores».

7.7 El canal de distribución en el manifiesto

Muchas apps chinas llevan escrito en el manifiesto el canal por el que se descargaron, en un <meta-data> con nombre UMENG_CHANNEL, JPUSH_CHANNEL o parecido. Cuentan como canal los nombres que acaban en channel (o channel_id, channel_name…) con un prefijo conocido; no cuentan notification, default_channel, release_channel, hotupdater, account_channel ni los de .line.. Lo llevan 55 de 100 apps del mercado chino, unas 40 de 658 de Google Play (las más instaladas; es un mínimo, porque las bases con com.google.android.gms y sus 823 <meta-data> pueden haber perdido algún canal) y prácticamente ninguna de F-Droid (4 de 4.766), IzzyOnDroid (1 de 1.402) o el sorteo (3 de 369). En el mercado chino, 54 de las 55 tienen valor (un manifiesto con más de 200 <meta-data> se leyó a mano con aapt2; ver los límites de la «sección 1 · Qué es y por qué existe»). Los valores más repetidos son developer-default (8), C01-GEztJH0JLdBC (8) y weibo (7); en Google Play, googleplay (5), GOOGLEPLAY (3), GoogleMarket (2) y playstore (2). Ejemplos: org.mazhuang.guanggoo (179, de F-Droid) con BUGLY_APP_CHANNEL y valor github, e com.absinthe.libchecker (2671, de IzzyOnDroid) con channel.

Para cambiar de canal hay que reescribir el AXML, y por eso aparecen manifiestos que no escribió aapt2. Otras apps ponen el canal en el bloque de firma en lugar de en el manifiesto. Walle (0x71777777) lo usan unas 24 de 99 piezas chinas con bloque de firma y 1 de Google Play; VasDolly (0x881155ff), 7 de 99 chinas. Un fichero de canal en META-INF/, 1 de 100 chinas. Un ejemplo de Walle es cn.ninegame.gamemanager (80506001, del mercado chino). Véase «APK Signing Block».

8. Recetas

Máquina de referencia: macOS, aapt2 2.20-15087165 (de las build-tools 37.0.0), apktool 3.0.3 y jadx 1.5.6. Los ejemplos de esta sección usan Termux (com.termux 1022, de F-Droid).

8.1 Volcado del árbol y hexdump del manifiesto

BT=~/Library/Android/sdk/build-tools/37.0.0
APK=fdroid/com.termux_1022.apk      # ruta dentro del muestrario
$BT/aapt2 dump xmltree --file AndroidManifest.xml "$APK" | head -6
N: android=http://schemas.android.com/apk/res/android (line=2)
  E: manifest (line=2)
    A: http://schemas.android.com/apk/res/android:sharedUserId(0x0101000b)="com.termux" (Raw: "com.termux")
    A: http://schemas.android.com/apk/res/android:versionCode(0x0101021b)=1022
    A: http://schemas.android.com/apk/res/android:versionName(0x0101021c)="0.119.0-beta.3" (Raw: "0.119.0-beta.3")
    A: http://schemas.android.com/apk/res/android:sharedUserLabel(0x01010261)=@0x7f1000d9

Los mismos bytes, en crudo:

unzip -o -q "$APK" AndroidManifest.xml -d "$TMP"
xxd -l 32 "$TMP/AndroidManifest.xml"
00000000: 0300 0800 1839 0000 0100 1c00 781a 0000  .....9......x...
00000010: 8100 0000 0000 0000 0000 0000 2002 0000  ............ ...

Anotado a mano:

Bytes Campo Valor
03 00 header.type 0x0003 = RES_XML_TYPE
08 00 header.headerSize 8
18 39 00 00 header.size 0x3918 = 14.616, el fichero entero
01 00 type del primer subchunk 0x0001 = RES_STRING_POOL_TYPE
1c 00 headerSize 28
78 1a 00 00 size 0x1a78 = 6.776
81 00 00 00 stringCount 129
00 00 00 00 styleCount 0
00 00 00 00 flags 0 → UTF-16, no ordenado, como en todo manifiesto que aplane aapt2 («sección 3.1 · ResStringPool_header»)
20 02 00 00 stringsStart 0x220, relativo al inicio del pool (+0x08)

Y la primera cadena, en 0x08 + 0x220 = 0x228:

xxd -s 0x228 -l 16 "$TMP/AndroidManifest.xml"
00000228: 0500 7400 6800 6500 6d00 6500 0000 0500  ..t.h.e.m.e.....

05 00 = 5 caracteres, 74 00 68 00 65 00 6d 00 65 00 = theme en UTF-16LE, 00 00 = terminador. La cadena siguiente empieza acto seguido con su propio 05 00. La cuenta cuadra: 0x1c + 129 × 4 = 0x220.

8.2 Volcado de chunks propio

El volcador que produce las salidas de 3.3, 3.4 y 6.2 recorre los chunks con una función corta de python3 sin dependencias. Su núcleo:

def walk(b, off, end, depth):
    while off + 8 <= end:
        t  = u16(b, off)
        hs = u16(b, off + 2)
        size = u32(b, off + 4)
        print("%s+0x%06x %-30s headerSize=%d size=%d"
              % ("  " * depth, off, NOMBRES.get(t, "?"), hs, size))
        if size == 0:            # defensa contra el bucle infinito de 7.3
            return
        if t in (RES_XML_TYPE, RES_TABLE_TYPE, RES_TABLE_PACKAGE_TYPE):
            walk(b, off + hs, off + size, depth + 1)   # descender: off + hs, no off + 8
        off += size              # avanzar: off + size, no off + sizeof(struct)

Las dos líneas que importan son las dos últimas: descender por headerSize y avanzar por size. Un lector que use sizeof en cualquiera de las dos se rompe con el primer fichero producido por una versión de aapt2 distinta de la suya, y con todos los de la «sección 7 · Manifiestos malformados: ofuscación y evasión de análisis». Sobre el manifiesto de Termux:

fichero: AndroidManifest.xml  (14616 bytes)
+0x000000 RES_XML_TYPE                    headerSize=8   size=14616
  +0x000008 RES_STRING_POOL_TYPE            headerSize=28  size=6776 stringCount=129 styleCount=0 UTF-16
  +0x001a80 RES_XML_RESOURCE_MAP_TYPE       headerSize=8   size=164 ids=39
  +0x001b24 RES_XML_START_NAMESPACE_TYPE    headerSize=16  size=24
  +0x001b3c RES_XML_START_ELEMENT_TYPE      headerSize=16  size=236
  +0x001c28 RES_XML_START_ELEMENT_TYPE      headerSize=16  size=76
  +0x001c74 RES_XML_END_ELEMENT_TYPE        headerSize=16  size=24
  …

El manifiesto de Termux tiene 79 START_ELEMENT, 79 END_ELEMENT, 1 START_NAMESPACE, 1 END_NAMESPACE, ningún CDATA y ningún comentario, con el orden pool > mapa > nodos. El volcador completo, con las opciones que producen las salidas de 3.3, 3.4 y 6.2, es MUESTRARIO_RAIZ=<carpeta del muestrario> python3 -I scripts/muestrario/cifras/manifiesto_1.py --volcar <AXML> [--nivel N] [--cadenas] [--atributos N] [--mapa]: --cadenas enseña los casos de las trampas del pool, --atributos N los atributos del START_ELEMENT número N y --mapa el resource map con la cadena de cada índice.

8.3 apktool

apktool d -f -o salida "$APK"
head -3 salida/AndroidManifest.xml
I: Using Apktool 3.0.3 on com.termux_1022.apk
I: Loading resource table...
I: Baksmaling classes2.dex...
I: Baksmaling classes.dex...
I: Decoding value resources...
I: Loading resource table from file: …/framework/1.apk
I: Decoding file resources...
I: Generating values XMLs...
I: Decoding AndroidManifest.xml with resources...
I: Copying original files...
I: Copying lib...
I: Copying unknown files...
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android" android:compileSdkVersion="30" android:compileSdkVersionCodename="11" android:installLocation="internalOnly" android:sharedUserId="com.termux" android:sharedUserLabel="@string/shared_user_label" package="com.termux" platformBuildVersionCode="30" platformBuildVersionName="11">
    <uses-feature android:name="android.hardware.touchscreen" android:required="false"/>

-f fuerza el borrado del directorio de destino y -o fija su nombre. Terminó con código 0 en 3 segundos y escribió 2.743 ficheros smali de los dos DEX (classes.dex y classes2.dex). Lo verificamos con apktool 3.0.3 el 31 de octubre de 2026.

Fíjate en la línea Decoding AndroidManifest.xml with resources: apktool resuelve las referencias contra resources.arsc antes de escribir el XML, y por eso puede emitir @string/shared_user_label donde el AXML guarda un 0x7f…. Es la diferencia práctica con aapt2 dump xmltree, que enseña el identificador numérico crudo.

Fuentes

  1. frameworks/base/libs/androidfw/include/androidfw/ResourceTypes.h (etiqueta android-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/libs/androidfw/include/androidfw/ResourceTypes.h Consultado el 25 de septiembre de 2026, descargado con ?format=TEXT y decodificado. De aquí salen íntegras las tablas de campos de las secciones «2.1», «2.2», «3.1», «3.4», «4.2» a 4.5 y 5, ResXMLTreeFlagExt («sección 4.4 · ResXMLTree_attrExt — tipo 0x0102, START_ELEMENT»; que aapt2 lo escribe sale de tools/aapt2/format/binary/XmlFlattener.cpp en la misma etiqueta) y las constantes RES_*, SORTED_FLAG, UTF8_FLAG, TYPE_* y COMPLEX_*. Reconsultado el 18 de octubre de 2026, con la cabecera de android-16.0.0_r1: RES_TABLE_FLAGGED y RES_TABLE_FLAG_LIST están en las líneas 264-265 de la de android-17.0.0_r1 y la de android-16.0.0_r1 no los define («sección 2.2 · Los valores de type»).
  2. frameworks/base/libs/androidfw/ResourceTypes.cpp (etiqueta android-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/libs/androidfw/ResourceTypes.cpp Consultado el 25 de septiembre de 2026. De aquí salen validate_chunk («sección 2.3 · La validación que aplica AOSP»), las dos funciones decodeLength (secciones «3.2» y «3.3»), la validación de ResStringPool::setTo (tabla 7.2), ResXMLTree::setTo e init, ResXMLTree::validateNode, ResXMLParser::nextNode y ResXMLParser::getAttributeNameResID («sección 6.1 · El mecanismo»). Reconsultado el 18 de octubre de 2026: ResXMLTree::init rechaza un headerSize mayor que el size del chunk raíz o un size mayor que los datos (línea 1912) y fija mDataEnd en header + size (línea 1926; líneas 1911-1926 en conjunto, «sección 7.3 · Técnicas observadas en la literatura»), y ResXMLParser::indexOfAttribute recorre los atributos uno a uno (desde la línea 1622, «sección 6.3 · Consecuencia para quien edita»). En la misma consulta: una cadena UTF-8 sin el 00 detrás de utf8len se rechaza con «string #%d is not null-terminated» en ResStringPool::stringDecodeAt (líneas 999-1029, el mensaje en la 1027); el de UTF-16 es el de la línea 840 («sección 3.3 · Codificación UTF-8 y la trampa del doble campo»).
  3. frameworks/base/libs/androidfw/ResourceTypes.cpp en las etiquetas android-7.1.2_r36, android-11.0.0_r1, android-12.0.0_r1, android-13.0.0_r1, android-14.0.0_r1 y android-15.0.0_r1 — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-15.0.0_r1/libs/androidfw/ResourceTypes.cpp Consultado el 12 de agosto de 2026, las seis etiquetas. De aquí sale la tabla 7.4 sobre cuándo se introdujo la validación del tipo del chunk raíz.
  4. frameworks/base/tools/aapt2/Resource.h (etiqueta android-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/tools/aapt2/Resource.h Consultado el 25 de septiembre de 2026. De aquí sale la estructura 0xPPTTEEEE citada en 5.1 y las constantes kAppPackageId = 0x7f y kFrameworkPackageId = 0x01.
  5. Unpacking the Unpackable: Malformed APKs as an Anti-Analysis Technique — Cleafy Labs — https://www.cleafy.com/cleafy-labs/malformed-apks-as-an-anti-analysis-technique-malfixer-tool Consultado el 12 de agosto de 2026. De aquí salen las filas de la tabla 7.3 sobre magia alterada, stringCount inflado, offsets duplicados, attributeSize = 0x18 frente al 0x14 estándar y attributeStart arbitrario.
  6. Technical Analysis of Multi-layered Obfuscation Techniques in AndroidManifest.xml Aimed at Evading Static Analysis — Lian Security — https://www.liansecurity.com/news/article/H_NoQIoBE2npFSfF-iQ5 Consultado el 12 de agosto de 2026. Es donde se describieron las técnicas de la tabla 7.3 sobre headerSize mentiroso en START_ELEMENT y datos basura entre nodos; la fuente primaria de lo que hacen hoy aapt2, apktool y jadx ante ellas es la reproducción propia (fuente 15). Su afirmación de que Android no valida el tipo del chunk raíz se ha contrastado contra AOSP y corregido con fecha en 7.4. El 25 de septiembre de 2026 todo el dominio devolvía 500; el 18 de octubre de 2026 la URL vuelve a responder con el artículo, fechado el 29 de agosto de 2023.
  7. apktool — parámetros de la CLI — https://apktool.org/docs/cli-parameters Consultado el 12 de agosto de 2026. De aquí sale la sintaxis de la receta 8.3.
  8. apktool 3.0.3 — instalado y ejecutado el 31 de octubre de 2026 sobre Termux (com.termux 1022, de F-Droid). De aquí sale la salida real de la «sección 8.3 · apktool», incluida la resolución de referencias contra resources.arsc que la distingue de aapt2 dump xmltree.
  9. AOSP — libs/androidfw/StringPool.cpp y libs/androidfw/Util.cpp, etiqueta android-16.0.0_r1 — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-16.0.0_r1/libs/androidfw/Util.cpp Consultado el 24 de septiembre de 2026. De aquí sale que el pool UTF-8 pasa por Utf8ToModifiedUtf8, con los subrogados al estilo de CESU-8 («sección 3.3 · Codificación UTF-8 y la trampa del doble campo»).
  10. AOSP — libs/androidfw/AttributeResolution.cpp, etiqueta android-17.0.0_r1 — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/libs/androidfw/AttributeResolution.cpp Consultado el 25 de septiembre de 2026. De aquí sale el recorrido en paralelo de RetrieveAttributes, que exige los atributos en orden de resource ID («sección 6.3 · Consecuencia para quien edita»).
  11. AOSP — libs/androidfw/ResourceTypes.cpp, etiquetas android-16.0.0_r1, android-14.0.0_r28 y android-14.0.0_r29 — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-16.0.0_r1/libs/androidfw/ResourceTypes.cpp Consultado el 25 de septiembre de 2026. De aquí salen el ResStringPool_span de 0xFFFFFFFF que debe cerrar el bloque de estilos («last style is not 0xFFFFFFFF-terminated») y la búsqueda del string pool y del resource map solo hasta el primer nodo en ResXMLTree::setTo (secciones «4.1» y «7.2»), y que la comprobación «expected root block type» aparece en android-14.0.0_r29 y no en android-14.0.0_r28 («sección 7.4 · El caso de la magia, con fecha»).
  12. Build numbers — Android Open Source Project — https://source.android.com/docs/setup/reference/build-numbers Consultado el 25 de septiembre de 2026. De aquí sale que android-14.0.0_r29 corresponde a la compilación AP1A.240305.019.A1 de Android 14 («sección 7.4 · El caso de la magia, con fecha»).
  13. Reproducción con aapt2 2.20-15087165 (build-tools 37.0.0) — aapt2 compile y aapt2 link contra platforms/android-36, el 25 de septiembre de 2026. Un android:textColor="#ff0000" sale con tipo 0x1d (TYPE_INT_COLOR_RGB8) y valor 0xffff0000, y un res/raw/datos.xml y un assets/cfg.xml salen en texto, byte a byte iguales al fuente («sección 1 · Qué es y por qué existe»).
  14. AOSP — core/java/android/util/TypedValue.java y tools/aapt2/ResourceUtils.cpp, etiqueta android-17.0.0_r1 — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/util/TypedValue.java Consultado el 25 de septiembre de 2026, con libs/androidfw/ResourceTypes.cpp de la misma etiqueta. De aquí sale que los bits 6 y 7 de un valor complejo ni se escriben ni se leen («sección 5.2 · Números complejos: COMPLEX_*»).
  15. Reproducción de las técnicas de 7.3 — AndroidManifest.xml de Shelter (net.typeblog.shelter 445, de F-Droid) modificado con un script, leído el 25 de septiembre de 2026 con aapt2 2.20-15087165 (dump xmltree y dump badging), apktool 3.0.3 (d -s) y jadx 1.5.6 (--no-src). De aquí sale la tabla de reproducción de la «sección 7.4 · El caso de la magia, con fecha», y es la fuente primaria de lo que hacen aapt2 (libandroidfw), apktool 3.0.3 y jadx 1.5.6 ante las técnicas de 7.3 que reproduce: magia alterada, stringCount inflado, offsets fuera de rango, headerSize mentiroso, datos basura entre nodos, attributeSize, attributeStart, chunk de tamaño cero y END_ELEMENT de más. No sustituye a la columna «efecto en el analizador» de 7.3, que resume la literatura (fuentes 5 y 6): la contradice en attributeSize mayor que 0x14, en la magia alterada, que jadx no valida, y en el chunk de tamaño cero.
  16. AOSP — core/java/android/content/res/XmlBlock.java, Resources.java y flags.aconfig, core/jni/android_util_XmlBlock.cpp y android_util_AssetManager.cpp, y core/java/android/content/pm/parsing/ApkLiteParseUtils.java, etiqueta android-17.0.0_r1 — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/content/res/XmlBlock.java Consultado el 18 de octubre de 2026. De aquí salen que getAttributeValue(ns, name) resuelve con nativeGetAttributeIndex, que llama a indexOfAttribute (XmlBlock.java, líneas 319-320; android_util_XmlBlock.cpp, línea 258), que ApkLiteParseUtils lee así package (línea 916) y que obtainAttributes acaba en RetrieveAttributes (Resources.java, líneas 2174-2183; android_util_AssetManager.cpp, línea 1356) («sección 6.3 · Consecuencia para quien edita»); y que el ResXMLTreeFlagExt solo se interpreta con layout_readwrite_flags activo (XmlBlock.java, línea 349; flags.aconfig, líneas 107-115), un flag distinto de resource_readwrite_flags (líneas 117-124) («sección 4.4 · ResXMLTree_attrExt — tipo 0x0102, START_ELEMENT»).
  17. AOSP — tools/aapt2/format/binary/XmlFlattener.cpp, etiqueta android-17.0.0_r1 — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/tools/aapt2/format/binary/XmlFlattener.cpp Consultado el 18 de octubre de 2026. De aquí sale el orden en que aapt2 escribe un AXML: la cabecera RES_XML_TYPE, el string pool, el resource map y los nodos (líneas 347-374, «sección 3 · ResStringPool: la tabla de cadenas»), y que el pool sale en UTF-16 o en UTF-8 según use_utf16 (líneas 352-356, «sección 3.1 · ResStringPool_header»).
  18. AOSP — libs/androidfw/include/androidfw/ResourceTypes.h en la rama main — https://android.googlesource.com/platform/frameworks/base/+/1cdfff555f4a21f71ccc978290e2e212e2f8b168/libs/androidfw/include/androidfw/ResourceTypes.h Consultado el 18 de octubre de 2026. El último commit de main en frameworks/base es del 26 de marzo de 2025, y su ResourceTypes.h no tiene RES_TABLE_FLAGGED, RES_TABLE_FLAG_LIST ni ResXMLTreeFlagExt («sección 2.2 · Los valores de type»).
  19. AOSP — tools/aapt2/cmd/Link.cpp y libs/androidfw/StringPool.cpp, etiqueta android-17.0.0_r1 — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/tools/aapt2/cmd/Link.cpp Consultado el 18 de octubre de 2026. De aquí salen que aapt2 link aplana el manifiesto con utf16 = true (Link.cpp, líneas 1923-1924) y el resto de los XML con false (líneas 698-699), que FlattenXml lo pasa a XmlFlattenerOptions::use_utf16 (línea 263) («sección 3.1 · ResStringPool_header»), y que EncodeString reserva un byte más tras los datos de cada cadena UTF-8 (StringPool.cpp, líneas 370-371, «sección 3.3 · Codificación UTF-8 y la trampa del doble campo»).
  20. El muestrario — «El muestrario» De aquí salen las cifras de las secciones «1», «3.1», «3.3», «3.5», «4», «5.2», «6» y «7». Los ejemplos con bytes salen de Termux (com.termux 1022), F-Droid (org.fdroid.fdroid 2000052), Pachli (app.pachli 56) y Shelter (net.typeblog.shelter 445), los cuatro de F-Droid, descargados el 19 de octubre de 2026.