XML binario de Android (AXML)
Antes conviene leer «Anatomía de un APK» · se lee en paralelo con «Tabla de recursos»
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).
0xabre un número en hexadecimal.uint16_tyuint32_tson enteros sin signo de 2 y de 4 bytes.- Los índices cuentan desde 0, salvo
idIndex,classIndexystyleIndex, que cuentan desde 1 y valen 0 si no hay atributo. 0xFFFFFFFFen 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. Elbase.apkde UC Browser (com.uc.browser.en12.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 deres/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/niassets/(por ejemplor/): 154.672 ficheros en total. El APK de Douyin (com.ss.android.ugc.aweme400801) lleva 28.898 y ninguno dentro deres/. Un lector que busque AXML solo enres/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
0x64o, sin violar ninguna regla del lector,0x80 0x64; - el relleno hasta el múltiplo de 4 que exige
validate_chunk; stylesStartcuandostyleCount == 0, que casi siempre vale0(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.mail189185, que además va en UTF-8) ycom.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 deres/. 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 0x64en vez de0x64), pero ningún pool lo hace, ni en manifiestos, ni en XML deres/, ni enresources.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»). stylesStartdistinto de 0 sin estilos: un caso. El manifiesto de Netflix para Android TV (com.netflix.ninja13.2.1-27207, el mismo UTF-8 de la «sección 3.1 · ResStringPool_header») tiene un pool de 284 cadenas constyleCount0 ystylesStart0x2ba0, 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 (claveaxml.styles_start_manifiestos_utf8descripts/muestrario/cifras/ejemplos_1.py, que lee de cada uno los bytes0x20–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 guardastylesStart. 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 optimizeacorta 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 tipores/8G.xmlen 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 escn.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
idel array es elresource IDde la cadenaidel 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_valueconsizedistinto de 8: en el manifiesto, 2 de 100 chinas; enresources.arsc, 4 de 100 chinas.rawValueen 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
.xmlcompilado fuera deres/yassets/: 15 de 100 chinas. - Sin
platformBuildVersion*nicompileSdkVersion(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
frameworks/base/libs/androidfw/include/androidfw/ResourceTypes.h(etiquetaandroid-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=TEXTy 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»; queaapt2lo escribe sale detools/aapt2/format/binary/XmlFlattener.cppen la misma etiqueta) y las constantesRES_*,SORTED_FLAG,UTF8_FLAG,TYPE_*yCOMPLEX_*. Reconsultado el 18 de octubre de 2026, con la cabecera deandroid-16.0.0_r1:RES_TABLE_FLAGGEDyRES_TABLE_FLAG_LISTestán en las líneas 264-265 de la deandroid-17.0.0_r1y la deandroid-16.0.0_r1no los define («sección 2.2 · Los valores de type»).frameworks/base/libs/androidfw/ResourceTypes.cpp(etiquetaandroid-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í salenvalidate_chunk(«sección 2.3 · La validación que aplica AOSP»), las dos funcionesdecodeLength(secciones «3.2» y «3.3»), la validación deResStringPool::setTo(tabla 7.2),ResXMLTree::setToeinit,ResXMLTree::validateNode,ResXMLParser::nextNodeyResXMLParser::getAttributeNameResID(«sección 6.1 · El mecanismo»). Reconsultado el 18 de octubre de 2026:ResXMLTree::initrechaza unheaderSizemayor que elsizedel chunk raíz o unsizemayor que los datos (línea 1912) y fijamDataEndenheader + size(línea 1926; líneas 1911-1926 en conjunto, «sección 7.3 · Técnicas observadas en la literatura»), yResXMLParser::indexOfAttributerecorre 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 el00detrás deutf8lense rechaza con «string #%d is not null-terminated» enResStringPool::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»).frameworks/base/libs/androidfw/ResourceTypes.cppen las etiquetasandroid-7.1.2_r36,android-11.0.0_r1,android-12.0.0_r1,android-13.0.0_r1,android-14.0.0_r1yandroid-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.frameworks/base/tools/aapt2/Resource.h(etiquetaandroid-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 estructura0xPPTTEEEEcitada en 5.1 y las constanteskAppPackageId = 0x7fykFrameworkPackageId = 0x01.- 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,
stringCountinflado, offsets duplicados,attributeSize = 0x18frente al0x14estándar yattributeStartarbitrario. - 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
headerSizementiroso enSTART_ELEMENTy datos basura entre nodos; la fuente primaria de lo que hacen hoyaapt2,apktoolyjadxante 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. - 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.
- apktool 3.0.3 — instalado y ejecutado el 31 de octubre de 2026 sobre
Termux (
com.termux1022, de F-Droid). De aquí sale la salida real de la «sección 8.3 · apktool», incluida la resolución de referencias contraresources.arscque la distingue deaapt2 dump xmltree. - AOSP —
libs/androidfw/StringPool.cppylibs/androidfw/Util.cpp, etiquetaandroid-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 porUtf8ToModifiedUtf8, con los subrogados al estilo de CESU-8 («sección 3.3 · Codificación UTF-8 y la trampa del doble campo»). - AOSP —
libs/androidfw/AttributeResolution.cpp, etiquetaandroid-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 deRetrieveAttributes, que exige los atributos en orden de resource ID («sección 6.3 · Consecuencia para quien edita»). - AOSP —
libs/androidfw/ResourceTypes.cpp, etiquetasandroid-16.0.0_r1,android-14.0.0_r28yandroid-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 elResStringPool_spande0xFFFFFFFFque 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 enResXMLTree::setTo(secciones «4.1» y «7.2»), y que la comprobación «expected root block type» aparece enandroid-14.0.0_r29y no enandroid-14.0.0_r28(«sección 7.4 · El caso de la magia, con fecha»). - 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_r29corresponde a la compilaciónAP1A.240305.019.A1de Android 14 («sección 7.4 · El caso de la magia, con fecha»). - Reproducción con
aapt22.20-15087165 (build-tools37.0.0) —aapt2 compileyaapt2 linkcontraplatforms/android-36, el 25 de septiembre de 2026. Unandroid:textColor="#ff0000"sale con tipo0x1d(TYPE_INT_COLOR_RGB8) y valor0xffff0000, y unres/raw/datos.xmly unassets/cfg.xmlsalen en texto, byte a byte iguales al fuente («sección 1 · Qué es y por qué existe»). - AOSP —
core/java/android/util/TypedValue.javaytools/aapt2/ResourceUtils.cpp, etiquetaandroid-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, conlibs/androidfw/ResourceTypes.cppde 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_*»). - Reproducción de las técnicas de 7.3 —
AndroidManifest.xmlde Shelter (net.typeblog.shelter445, de F-Droid) modificado con un script, leído el 25 de septiembre de 2026 conaapt22.20-15087165 (dump xmltreeydump badging),apktool3.0.3 (d -s) yjadx1.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 hacenaapt2(libandroidfw),apktool3.0.3 yjadx1.5.6 ante las técnicas de 7.3 que reproduce: magia alterada,stringCountinflado, offsets fuera de rango,headerSizementiroso, datos basura entre nodos,attributeSize,attributeStart, chunk de tamaño cero yEND_ELEMENTde más. No sustituye a la columna «efecto en el analizador» de 7.3, que resume la literatura (fuentes 5 y 6): la contradice enattributeSizemayor que0x14, en la magia alterada, quejadxno valida, y en el chunk de tamaño cero. - AOSP —
core/java/android/content/res/XmlBlock.java,Resources.javayflags.aconfig,core/jni/android_util_XmlBlock.cppyandroid_util_AssetManager.cpp, ycore/java/android/content/pm/parsing/ApkLiteParseUtils.java, etiquetaandroid-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 quegetAttributeValue(ns, name)resuelve connativeGetAttributeIndex, que llama aindexOfAttribute(XmlBlock.java, líneas 319-320;android_util_XmlBlock.cpp, línea 258), queApkLiteParseUtilslee asípackage(línea 916) y queobtainAttributesacaba enRetrieveAttributes(Resources.java, líneas 2174-2183;android_util_AssetManager.cpp, línea 1356) («sección 6.3 · Consecuencia para quien edita»); y que elResXMLTreeFlagExtsolo se interpreta conlayout_readwrite_flagsactivo (XmlBlock.java, línea 349;flags.aconfig, líneas 107-115), un flag distinto deresource_readwrite_flags(líneas 117-124) («sección 4.4 · ResXMLTree_attrExt — tipo 0x0102, START_ELEMENT»). - AOSP —
tools/aapt2/format/binary/XmlFlattener.cpp, etiquetaandroid-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 queaapt2escribe un AXML: la cabeceraRES_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únuse_utf16(líneas 352-356, «sección 3.1 · ResStringPool_header»). - AOSP —
libs/androidfw/include/androidfw/ResourceTypes.hen la ramamain— https://android.googlesource.com/platform/frameworks/base/+/1cdfff555f4a21f71ccc978290e2e212e2f8b168/libs/androidfw/include/androidfw/ResourceTypes.h Consultado el 18 de octubre de 2026. El último commit demainenframeworks/basees del 26 de marzo de 2025, y suResourceTypes.hno tieneRES_TABLE_FLAGGED,RES_TABLE_FLAG_LISTniResXMLTreeFlagExt(«sección 2.2 · Los valores de type»). - AOSP —
tools/aapt2/cmd/Link.cppylibs/androidfw/StringPool.cpp, etiquetaandroid-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 queaapt2 linkaplana el manifiesto conutf16 = true(Link.cpp, líneas 1923-1924) y el resto de los XML confalse(líneas 698-699), queFlattenXmllo pasa aXmlFlattenerOptions::use_utf16(línea 263) («sección 3.1 · ResStringPool_header»), y queEncodeStringreserva 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»). - 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.termux1022), F-Droid (org.fdroid.fdroid2000052), Pachli (app.pachli56) y Shelter (net.typeblog.shelter445), los cuatro de F-Droid, descargados el 19 de octubre de 2026.