Código nativo y ELF
Antes conviene leer «Contenedor ZIP»
1. Qué es y por qué existe
No todo el código de una aplicación Android es DEX. Una biblioteca nativa es código ya
traducido a instrucciones del procesador. Va en ficheros .so dentro de lib/<abi>/, donde
<abi> es el tipo de procesador (arm64-v8a es el de casi todos los móviles actuales). Tienen
formato ELF, el de los programas de Linux, se escriben en C, C++ u otros lenguajes y se
compilan con el NDK, el kit de Google para eso. El código Java o Kotlin las llama a través de
JNI.
Para repetir las cifras: MUESTRARIO_RAIZ=<raíz> python3 -I scripts/muestrario/cifras/nativo_1.py --salida.
El código nativo es lo normal, no la excepción. Lo llevan más de la mitad de las apps de F-Droid e IzzyOnDroid, casi todas las de Google Play más instaladas (93 %) y las 100 del mercado chino.
Y las .so que más se repiten no son códecs ni motores de juego, sino piezas pequeñas de
bibliotecas. En F-Droid la primera es libandroidx.graphics.path.so, de Jetpack, que está en una
de cada dos apps con código nativo. Un ejemplo es la de F-Droid Client (org.fdroid.fdroid,
versión 2000052): 10.096 B en arm64-v8a, compilada con el NDK r25c. Le siguen
libdatastore_shared_counter.so, también de Jetpack, y libflutter.so. En Google Play más
instaladas manda otra vez libdatastore_shared_counter.so (53 %), seguida de libc++_shared.so,
el soporte de C++ del NDK, y libcrashlytics.so. Todas se cuentan por el nombre del fichero. Si
buscas motores de juego, mira el sorteo de Play: libunity.so y libil2cpp.so, de Unity, están
en una de cada cuatro apps.
Además pesan. En la mediana de las apps con código nativo, las .so ocupan alrededor de un tercio
de los bytes comprimidos de la app si cuentas todas las ABI de la descarga. Con una sola ABI, la
mediana va del 8 % en IzzyOnDroid al 28 % en el mercado chino.
Con análisis estático se ve qué hay en cada .so, no por qué lo puso su autor. Los motivos que
se suelen dar son el rendimiento, la reutilización de bibliotecas en C y C++ que nadie va a
reescribir y la ocultación del código. Ninguno se puede comprobar con medidas estáticas.
Lo que sí se ve es el rastro de un método movido a .so: desaparece del
«bytecode Dalvik». En el DEX queda una declaración native sin cuerpo, y
un decompilador a Java no ve lo que hay detrás. El análisis se para ahí, salvo que cambies de
herramienta y de nivel. Ojo: no siempre hay una .so en lib/ que lo explique. Pasa en pocas
apps de F-Droid (49 de 4.766) y en casi una de cada diez del sorteo de Play; en el mercado chino y
en las webs de autores, en ninguna. La medida no dice de dónde sale ese
código. Puede estar en ficheros ELF dentro de assets/, llegar con una descarga posterior o venir
de un cargador («sección 4.1 · Cargar la biblioteca»). Contamos un método como nativo si lleva el bit ACC_NATIVE
(0x100) en cualquiera de los DEX de la app.
Este documento cubre lo que hace falta para inventariar, identificar y decidir: qué ABIs trae un APK, cómo se enlaza cada método nativo, qué exige la regla de las páginas de 16 KB y qué se ha perdido al hacer stripping. El análisis del código nativo en sí —Ghidra, radare2, IDA— está en «Análisis binario y estático».
Endianness: el orden en que se guardan los bytes de un número. Las cuatro ABIs vigentes de Android son little-endian (
ELFDATA2LSB): un número de varios bytes empieza por el byte menos significativo, y0x1234se escribe34 12. ElELFlo declara en su byte 5 (EI_DATA= 1). De las 73.723.sodelib/<abi>/que el medidor pudo leer, ninguna es big-endian, y tampoco las de las cinco apps de protectores que añadimos a propósito. En las tablas de este documento, cada offset cuenta desde el principio de la estructura que se describe.
2. lib/<abi>/ y las ABIs vigentes
El empaquetado es una convención sobre rutas del ZIP: un directorio por ABI bajo lib/, y
dentro las .so, sin más subdirectorios. Casi todas las apps la respetan; la rompen un puñado
(3 de 2.710 en F-Droid, 2 de 100 en el mercado chino). Cuando pasa, suele ser por bibliotecas Java
con sus nativos de escritorio dentro, como lib/amd64-Windows-gpp/jni/… en com.tht.k3pler, o
por un .jar suelto como lib/commons-io-2.4.jar en org.hzontal.tellaFOSS. También hay una
carpeta que no es una ABI: lib/arm/libDTMFLIB.so en la variante de APKMirror de
com.samsung.android.app.bikemode 3.0.24. Nada de eso importa al instalador, que solo mira
lib/<abi>/.
El instalador mira los lib/<abi>/ de todos los APK
del conjunto y se queda con uno solo: el de la primera ABI de Build.SUPPORTED_ABIS que tenga
directorio. Esa pasa a ser la ABI primaria de la aplicación, todas sus .so salen de ahí —no se
mezclan directorios— y el proceso arranca con ella (findSupportedAbi en
com_android_internal_content_NativeLibraryHelper.cpp, líneas 488-542; NativeLibraryHelper.java,
líneas 234-255; PackageAbiHelperImpl.java, líneas 468-520, y ProcessList.java, líneas
2033-2046, en android-17.0.0_r1). De ahí salen tres consecuencias:
- Una aplicación que solo trae
lib/armeabi-v7a/se instala en un teléfono de 64 bits que admita también 32 bits (armeabi-v7ava detrás en suBuild.SUPPORTED_ABIS) y corre como proceso de 32 bits, aunque el teléfono sea de 64. En el muestrario hay pocas apps así, y casi todas se explican por cómo se descargaron. En Play más instaladas son 69 de 615, pero 46 son variantes de APKMirror de una sola arquitectura (por ejemplo la decom.facebook.lite534.0.0.7.108) y 17 son.xapkde APKPure con solo el splitarmeabi-v7a(por ejemplo la piezacom.playrix.township.apkde Township 39.1.2). Quedan 6 (5.apkmy 1.apk) sin abrir uno a uno. En F-Droid e IzzyOnDroid son pocas, comocom.wrmndfzzy.atomizeocom.bugsdev2.bookaccio, las dos solo conarmeabi-v7a. Así que estas cifras no prueban que Google Play siga sirviendo apps solo de 32 bits: describen lo descargado. - Si hay
lib/pero ninguna ABI coincide, la instalación falla conINSTALL_FAILED_NO_MATCHING_ABIS(res=-113). El literal, medido, está en la «sección 6.2 de Formatos y extensiones · Extraer el base». - Google Play pide además la versión de 64 bits: desde el 1 de agosto de 2019, a las aplicaciones nuevas y a las actualizaciones con código nativo, y desde el 1 de agosto de 2021 deja de servir las que no la tienen a los dispositivos de 64 bits.
La excepción es android:multiArch="true": entonces el instalador elige dos ABIs, la mejor de 32
bits y la mejor de 64, cada una en su lista (Build.SUPPORTED_32_BIT_ABIS y
Build.SUPPORTED_64_BIT_ABIS), y la aplicación queda con una primaria y una secundaria; la de 64
bits va primero salvo que el paquete prefiera la de 32 (is32BitAbiPreferred())
(PackageAbiHelperImpl.java, líneas 385-466). No hemos contado cuántas apps lo declaran. Un caso
real es Samsung Internet 30.0.5.27 (la versión de APKPure): multiArch="true", con arm64-v8a
como código nativo y armeabi-v7a como alternativo (alt-native-code). Con targetSdk 35 o
superior, y sin una ABI forzada con cpuAbiOverride, esas dos listas se reducen a las ABIs que el
dispositivo ejecuta de forma nativa, sin las que emula un native bridge
(getNativelySupported32BitAbis y getNativelySupported64BitAbis, líneas 316-345 y 386-396).
2.1 Las cuatro vigentes
| ABI | CPU | Nota de la documentación del NDK |
|---|---|---|
arm64-v8a |
ARM de 64 bits | «Armv8.0 only.» long double de 128 bits |
armeabi-v7a |
ARM de 32 bits | «Incompatible with ARMv5/v6 devices.» Incluye Thumb-2 y Neon |
x86_64 |
x86 de 64 bits | «Full x86-64-v2» |
x86 |
x86 de 32 bits | «No support for MOVBE or SSE4.» |
Cuántas apps traen cada una: «sección 2.3 · Qué ABIs se empaquetan hoy».
2.2 Las eliminadas
«Historically the NDK supported ARMv5 (armeabi), and 32-bit and 64-bit MIPS, but support for these ABIs was removed in NDK r17.»
armeabi, mips y mips64 ya no se pueden compilar con un NDK moderno. Y aun así siguen
apareciendo en APK de 2026. Una biblioteca Java de terceros puede traer sus .so precompilados
de hace diez años dentro del .jar, y el empaquetador los copia sin preguntar. Pasa en pocas
apps (63 de las 2.709 de F-Droid con código nativo, un 2 %), y muchas de ellas son recientes: 22
de esas 63 llevan targetSdk 35 o más. La causa más repetida es JNA: en 19 de las 63, la única
.so de esas carpetas es libjnidispatch.so. Las demás traen bibliotecas viejas de otro origen, como
libgdx.so y libgdx-box2d.so (motor libGDX), libpl_droidsonroids_gif.so o libjniPdfium.so.
Un ejemplo con las siete carpetas es Tuta (de.tutao.tutanota, versión 396715), con targetSdk 36:
| Directorio | Entradas | Bytes |
|---|---|---|
arm64-v8a |
6 | 16.218.568 |
armeabi-v7a |
6 | 11.183.636 |
x86_64 |
6 | 18.552.536 |
x86 |
4 | 6.378.716 |
armeabi |
1 | 126.980 |
mips |
1 | 130.556 |
mips64 |
1 | 150.256 |
Fíjate en dos cosas. Los tres directorios retirados tienen una sola .so, y la ABI x86 tiene
cuatro entradas frente a las seis de las demás: le faltan libsignal_tokenizer.so y
libtutasdk.so.
Los tres directorios retirados de Tuta guardan el mismo fichero: libjnidispatch.so, de JNA,
una biblioteca de Java para llamar a código nativo. Y no es casualidad. La copia de armeabi de
126.980 B está en 17 apps del muestrario (15 de F-Droid y 3 de IzzyOnDroid; una está en las dos)
y, en 16 de ellas, es idéntica byte a byte (SHA-256
101daa2222382f3727800c0c49731346c5c4f81f1ecf1fde85ebcea64b151901). La copia de
com.armanmaurya.internetradio tiene el mismo tamaño y otro contenido. Las de mips (130.556 B)
y mips64 (150.256 B) están en 16 apps cada una. Sus SHA-256, leídos el 31 de octubre de 2026,
son eb549d34eb17b394f4ba74c21c51f41340d8b049aa90cc9feaef734695890402
y 93f5b0bec919b95160db0bf35c5ed6904d4d48f282501f0ff4a85f6511f3e44d. aapt2 dump badging declara
las siete carpetas como ABIs soportadas: native-code: 'arm64-v8a' 'armeabi' 'armeabi-v7a' 'mips' 'mips64' 'x86' 'x86_64'. JNA no explica todo: en 19 de las 63 apps de F-Droid con alguna carpeta
retirada, libjnidispatch.so es la única .so de esas carpetas; en las demás hay motores y
bibliotecas viejas.
Consecuencia para un inventario: contar directorios bajo lib/ no da las ABIs que la
aplicación soporta de verdad, da las que alguien empaquetó. Y no todas las ABI traen lo mismo: en
una de cada veinte apps de F-Droid con dos ABI o más, alguna trae menos bibliotecas que otra, y en
Google Play más instaladas, en una de cada cuatro. Es lo que le pasa a la x86 de Tuta. En Play, com.google.ar.core (la versión de APKPure,
1.57.262640083) trae dos .so en arm64-v8a y una en armeabi-v7a. En Play el reparto mezcla
ABIs de la propia app con splits y variantes de la descarga, y no hemos mirado la causa de cada
caso.
riscv64 está admitido para los dispositivos y no para las aplicaciones. Desde el CDD de
Android 15, la lista cerrada de ABIs que un dispositivo compatible puede declarar en
Build.SUPPORTED_ABIS incluye riscv64 (apartado 3.3.1, [C-0-6]; el CDD de Android 14 no lo menciona).
El NDK, en cambio, no lo soporta: el changelog de r27 dice que su sysroot «is not supported. It
is present to aid bringup for OS vendors, but it's not yet a supported Android ABI», los de r28
a r30 no lo mencionan, y la página de ABIs del NDK (actualizada el 15 de mayo de 2026) tampoco.
Aun así, 2 de las 15.183 piezas del muestrario traen lib/riscv64/: RF Analyzer
(com.mantz_it.rfanalyzer, versión 20208), con libunrooted_android.so y libusb1.0.so, y
KernelSU (me.weishu.kernelsu, versión 32680), con libadbroot.so, libkernelsu.so y
libksud.so. Las .so de riscv64 de las dos tienen p_align 0x1000 (4 KiB). Ninguna pieza
trae un split riscv64. Son una app de F-Droid y una de IzzyOnDroid, y ninguna de Play, del
mercado chino ni de las webs de autores.
2.3 Qué ABIs se empaquetan hoy
Cuántas apps llevan cada ABI, entre las que tienen código nativo. Cada celda es el número de apps
del grupo con alguna .so en esa carpeta, en cualquiera de las piezas de la descarga:
| ABI | F-Droid | IzzyOnDroid | Google Play más instaladas | Google Play sorteo | Mercado chino | Webs de autores |
|---|---|---|---|---|---|---|
arm64-v8a |
2.689 de 2.709 · 99 % | 790 de 820 · 96 % | 546 de 615 · 89 % | 310 de 311 · 100 % | 98 de 100 | 5 de 6 |
armeabi-v7a |
2.071 de 2.709 · 76 % | 617 de 820 · 75 % | 468 de 615 · 76 % | 27 de 311 · 9 % | 32 de 100 | 4 de 6 |
x86_64 |
1.982 de 2.709 · 73 % | 554 de 820 · 68 % | 165 de 615 · 27 % | 21 de 311 · 7 % | 0 de 100 | 2 de 6 |
x86 |
1.705 de 2.709 · 63 % | 513 de 820 · 63 % | 143 de 615 · 23 % | 18 de 311 · 6 % | 1 de 100 | 2 de 6 |
armeabi |
61 de 2.709 · 2 % | 11 de 820 · 1 % | 9 de 615 · 1 % | 2 de 311 | 3 de 100 | 0 de 6 |
mips |
37 de 2.709 · 1 % | 11 de 820 · 1 % | 0 de 615 | 0 de 311 | 0 de 100 | 0 de 6 |
mips64 |
29 de 2.709 · 1 % | 10 de 820 · 1 % | 0 de 615 | 0 de 311 | 0 de 100 | 0 de 6 |
riscv64 |
1 de 2.709 | 1 de 820 | 0 de 615 | 0 de 311 | 0 de 100 | 0 de 6 |
Cómo se lee: casi todas llevan arm64-v8a (el 99 % de F-Droid y el 96 % de IzzyOnDroid).
armeabi-v7a va en tres de cada cuatro apps de F-Droid, IzzyOnDroid y Play más instaladas, pero
solo en 27 de 311 del sorteo de Play, porque las carpetas de adb traen solo la ABI del teléfono.
x86 y x86_64 están en más de seis de cada diez apps de F-Droid y en menos de una de cada cuatro
de Play más instaladas; en el mercado chino, x86 está en 1 de 100 y x86_64 en ninguna. Las ABIs
retiradas son raras («sección 2.2 · Las eliminadas») y riscv64 casi inexistente. Las cifras de Play dependen de la
descarga: 46 de las 69 apps de Play más instaladas sin ABI de 64 bits son variantes de una sola
arquitectura («sección 2 · lib/<abi>/ y las ABIs vigentes»).
Las combinaciones cuentan algo parecido. En F-Droid lo más frecuente es llevar las cuatro ABIs
vigentes (el 60 %), y después, solo arm64-v8a. En Google Play más instaladas gana la pareja
arm64-v8a y armeabi-v7a (38 %), y en el mercado chino, solo arm64-v8a (65 de 100). La
diferencia está en x86: entre las apps con dos ABI vigentes o más, prescinden de x86 y x86_64
solo un 5 % en F-Droid, pero el 59 % en Play más instaladas y casi todas en el mercado chino. Un
ejemplo con las cuatro ABIs vigentes y tres .so cada una es el WhatsApp.apk de la web de
WhatsApp.
2.4 Dónde van las .so en las apps de Google Play
Una app de Google Play no es siempre un solo APK. Se reparte en una base (base.apk) y varios
splits, y las bibliotecas nativas viajan en los splits de ABI, split_config.<abi>.apk (o
config.<abi>.apk en los .xapk). Cuando una app de Play llega partida en splits, la base casi
nunca trae .so: pasa en el 96 % de las más instaladas y en todas las del sorteo. En los demás
grupos (F-Droid, IzzyOnDroid, mercado chino y webs de autores), todas las .so están en la pieza
única.
Un ejemplo: el split_config.arm64_v8a.apk del .apkm de Google Play Newsstand
(com.google.android.apps.magazines, 5.168.0). Otro del sorteo: el split_config.arm64_v8a.apk
de la carpeta de adb de com.mad.swap.
Lo que significa para el inventario: unzip -l base.apk | grep '^lib/' no encuentra nada en la
mayoría de las apps de Play. Hay que abrir cada split de ABI («sección 8.1 · Inventariar las ABIs presentes»). Y lo que hay depende de
la descarga: un .apkm y un .xapk traen los splits de varias ABIs, y una carpeta sacada con adb,
solo la del teléfono. Los formatos se describen en
«AAB, splits y contenedores».
De las 658 apps de Play más instaladas, 388 son .apkm (59 %), 68 .xapk (10 %) y 202 .apk
sueltos (31 %). En el sorteo de Play, 365 de 369 apps son carpetas de adb (99 %).
3. Estructura mínima de un ELF compartido
Una .so de Android casi siempre es un ELF de tipo ET_DYN (3, «Shared object file»), pero no
siempre. En el muestrario hay 150 ficheros de lib/<abi>/ de tipo ET_EXEC (ejecutables), frente
a 73.573 ET_DYN, y muchos ET_DYN con PT_INTERP, un segmento que pide un intérprete
(/system/bin/linker64). Son programas PIE con nombre de biblioteca. Algunas apps empaquetan
binarios (proot, tor, busybox, OpenVPN) como lib*.so, para poder lanzarlos desde el
directorio de bibliotecas nativas. Un ejecutable necesita una ruta de fichero, y los ejemplos
declaran extractNativeLibs="true": com.gwitko.conduit (libproot_loader.so),
com.inspiredandroid.kai (libproot-loader.so y libproot-loader32.so) y
com.ivarna.fluxlinux (libloader.so y libloader32.so). Una libtorexec.so es ET_DYN con
PT_INTERP en app.michaelwuensch.bitbanana.
Las .so que no son ET_DYN son raras: solo aparecen en unas pocas apps de F-Droid e
IzzyOnDroid. Si cuentas también las que llevan PT_INTERP, la cosa cambia: están en el 7 % de las
apps de F-Droid, en casi la mitad de las de Play más instaladas (45 %) y en 80 de 100 del mercado
chino. En Play la culpa es sobre todo de una sola biblioteca, libcrashlytics-trampoline.so, de
Firebase Crashlytics; en F-Droid se reparten entre libjnidispatch.so, libtor.so y
libovpnexec.so.
Interesan tres capas: la cabecera, la tabla de program headers —lo que el cargador usa— y la tabla de
secciones —lo que el analista usa—.
┌─────────────────────────────────────────┐ 0x00
│ Elf64_Ehdr (64 bytes) │
├─────────────────────────────────────────┤ e_phoff (típicamente 0x40)
│ Elf64_Phdr[e_phnum] (56 bytes cada uno)│ ← lo que mapea el cargador
├─────────────────────────────────────────┤
│ .dynsym .dynstr .text .rodata .init_array│ segmentos PT_LOAD
│ .data.rel.ro .dynamic .got │
├─────────────────────────────────────────┤ e_shoff
│ Elf64_Shdr[e_shnum] (64 bytes cada uno)│ ← la exige el cargador de Android (3.6)
└─────────────────────────────────────────┘
3.1 Cabecera ELF64
| Campo | Offset | Tamaño | Tipo | Significado |
|---|---|---|---|---|
e_ident |
0x00 | 16 | unsigned char[16] |
Identificación. Ver 3.2 |
e_type |
0x10 | 2 | Elf64_Half |
ET_DYN = 3 en casi toda biblioteca compartida (150 ET_EXEC en el muestrario, «sección 3 · Estructura mínima de un ELF compartido») |
e_machine |
0x12 | 2 | Elf64_Half |
Arquitectura. Ver 3.3 |
e_version |
0x14 | 4 | Elf64_Word |
1 |
e_entry |
0x18 | 8 | Elf64_Addr |
Punto de entrada. 0 o irrelevante en un .so |
e_phoff |
0x20 | 8 | Elf64_Off |
Offset de la tabla de program headers. 0x40 |
e_shoff |
0x28 | 8 | Elf64_Off |
Offset de la tabla de secciones. El gABI admite 0 si no la hay; el cargador de Android la exige («sección 3.6 · Secciones, símbolos y tabla dinámica») |
e_flags |
0x30 | 4 | Elf64_Word |
Banderas específicas de la arquitectura |
e_ehsize |
0x34 | 2 | Elf64_Half |
Tamaño de esta cabecera: 0x40 = 64 |
e_phentsize |
0x36 | 2 | Elf64_Half |
Tamaño de un program header: 0x38 = 56 |
e_phnum |
0x38 | 2 | Elf64_Half |
Número de program headers |
e_shentsize |
0x3A | 2 | Elf64_Half |
Tamaño de una cabecera de sección: 0x40 = 64 |
e_shnum |
0x3C | 2 | Elf64_Half |
Número de secciones |
e_shstrndx |
0x3E | 2 | Elf64_Half |
Índice de la sección con los nombres de sección |
En ELF32 la cabecera mide 52 bytes (0x34) y los campos de dirección son de 4 bytes; el
resto del esquema es idéntico.
3.2 e_ident
| Índice | Nombre | Tamaño | Valor en un .so de Android |
|---|---|---|---|
| 0–3 | EI_MAG0–EI_MAG3 |
4 | 7F 45 4C 46 (\x7fELF) |
| 4 | EI_CLASS |
1 | 2 = ELFCLASS64, 1 = ELFCLASS32 |
| 5 | EI_DATA |
1 | 1 = ELFDATA2LSB |
| 6 | EI_VERSION |
1 | 1 |
| 7 | EI_OSABI |
1 | 0 |
| 8 | EI_ABIVERSION |
1 | 0 |
| 9–15 | EI_PAD |
7 | ceros |
3.3 e_machine por ABI
| ABI | e_machine |
Constante |
|---|---|---|
arm64-v8a |
183 (0xB7) |
EM_AARCH64 |
armeabi-v7a |
40 (0x28) |
EM_ARM |
x86_64 |
62 (0x3E) |
EM_X86_64 |
x86 |
3 (0x03) |
EM_386 |
La ABI se deduce del binario, no de la ruta. Una .so colocada en el directorio
equivocado solo se detecta leyendo e_machine. Pasa poco fuera del mercado chino: 5 de las 2.709
apps de F-Droid con código nativo, 4 de 820 de IzzyOnDroid, 7 de 615 de Play más instaladas y 1 de
311 del sorteo. En el mercado chino, 31 de 100. El caso más repetido son las .so de x86-64 en
lib/arm64-v8a/: 42 de los 100 ficheros que no coinciden con su carpeta. Por ejemplo,
libDexHelper-x86.so de cn.cj.pe (tienda 360) está en lib/arm64-v8a/ con e_machine 62
(EM_X86_64) y en lib/armeabi-v7a/ con e_machine 3 (EM_386). Es una biblioteca del
protector Bangcle/SecNeo, por su nombre.
3.4 program header
| Campo | Offset | Tamaño | Tipo | Significado |
|---|---|---|---|---|
p_type |
0x00 | 4 | Elf64_Word |
PT_LOAD = 1, PT_DYNAMIC = 2, PT_NOTE = 4, PT_PHDR = 6 |
p_flags |
0x04 | 4 | Elf64_Word |
Permisos: r, w, x |
p_offset |
0x08 | 8 | Elf64_Off |
Offset dentro del fichero |
p_vaddr |
0x10 | 8 | Elf64_Addr |
Dirección virtual |
p_paddr |
0x18 | 8 | Elf64_Addr |
Dirección física. Irrelevante |
p_filesz |
0x20 | 8 | Elf64_Xword |
Bytes en el fichero |
p_memsz |
0x28 | 8 | Elf64_Xword |
Bytes en memoria. Mayor que p_filesz si hay .bss |
p_align |
0x30 | 8 | Elf64_Xword |
El campo de la regla de 16 KB («sección 6 · Páginas de 16 KB») |
Es el Elf64_Phdr, de 56 bytes. En ELF32 (armeabi-v7a, x86) el Elf32_Phdr mide 32
bytes y cambia el orden: p_type en 0x00, p_offset en 0x04, p_vaddr en 0x08, p_paddr en
0x0C, p_filesz en 0x10, p_memsz en 0x14, p_flags en 0x18 y p_align en 0x1C, todos
de 4 bytes.
«This member gives the value to which the segments are aligned in memory and in the file. Values 0 and 1 mean no alignment is required.»
y para los segmentos cargables, «p_vaddr should equal p_offset, modulo p_align».
3.5 Secciones que importan al analizar
| Sección | Contenido | Para qué sirve al analista |
|---|---|---|
.dynsym |
Tabla de símbolos dinámicos | La única tabla de símbolos que sobrevive al stripping. De ahí salen los Java_* y JNI_OnLoad |
.dynstr |
Nombres de .dynsym |
Los strings de los símbolos exportados e importados |
.text |
Código máquina | Lo que se desensambla |
.rodata |
Datos de solo lectura | Cadenas literales, tablas, claves embebidas |
.init_array |
Punteros a constructores | Se ejecutan antes que JNI_OnLoad: un sitio posible para el descifrado inicial y las comprobaciones anti-análisis (ver debajo de la tabla) |
.fini_array |
Punteros a destructores | Simétrico del anterior |
.dynamic |
NEEDED, SONAME, tablas de relocalización |
El grafo de dependencias entre .so |
.symtab |
Tabla de símbolos completa | Ausente en casi todas las .so de producción. Ver «sección 7 · Stripping de símbolos» |
.note.android.ident |
Versión del NDK y minSdk de compilación |
Huella de la cadena de build |
.init_array guarda punteros a funciones que se ejecutan al cargar la biblioteca, antes de
JNI_OnLoad. Es un sitio posible para descifrar el código o hacer comprobaciones anti-análisis,
pero eso no se puede comprobar de forma estática. Lo que se mide es que las bibliotecas de
protectores conocidos (por nombre, 201 ficheros) tienen más constructores que el resto (73.908):
mediana de 4 punteros frente a 0, y 24 frente a 10 en el percentil 90; el máximo es 70 frente a
11.906. El número no basta para identificar un protector.
El grafo de dependencias se lee sin NDK con el mismo objdump de la «sección 8 · Recetas»:
objdump -p lib.so | grep -E 'NEEDED|SONAME' imprime una línea NEEDED por cada biblioteca de
la que depende y, si la tiene, su SONAME. Sobre libtermux.so de Termux (com.termux, versión
0.119.0-beta.3; fuente 26), con objdump Apple LLVM 21.0.0, el 31 de octubre de 2026:
NEEDED libc.so
NEEDED libm.so
NEEDED libstdc++.so
NEEDED libdl.so
SONAME libtermux.so
Son las mismas entradas que se leen a mano en la «sección 3.6 · Secciones, símbolos y tabla dinámica».
3.6 Secciones, símbolos y tabla dinámica
Lo que hace falta para listar los símbolos de un .so —los Java_* del triaje de la «sección
4.4 · Por qué RegisterNatives complica el análisis estático»— sin objdump. Las estructuras salen del gABI y de libc/kernel/uapi/linux/elf.h de bionic;
los offsets son de ELF64, y las diferencias de ELF32 van al final.
Elf64_Shdr: 64 bytes por sección, e_shnum seguidas a partir de e_shoff.
| Campo | Offset | Tamaño | Tipo | Significado |
|---|---|---|---|---|
sh_name |
0x00 | 4 | Elf64_Word |
Offset del nombre dentro de la sección e_shstrndx |
sh_type |
0x04 | 4 | Elf64_Word |
SHT_PROGBITS = 1, SHT_SYMTAB = 2, SHT_STRTAB = 3, SHT_RELA = 4, SHT_HASH = 5, SHT_DYNAMIC = 6, SHT_NOTE = 7, SHT_NOBITS = 8, SHT_DYNSYM = 11 |
sh_flags |
0x08 | 8 | Elf64_Xword |
Banderas SHF_* |
sh_addr |
0x10 | 8 | Elf64_Addr |
Dirección virtual de la sección en memoria, o 0 |
sh_offset |
0x18 | 8 | Elf64_Off |
Offset en el fichero |
sh_size |
0x20 | 8 | Elf64_Xword |
Tamaño en bytes |
sh_link |
0x28 | 4 | Elf64_Word |
En SHT_DYNSYM, SHT_SYMTAB y SHT_DYNAMIC, el índice de su tabla de cadenas |
sh_info |
0x2C | 4 | Elf64_Word |
En SHT_DYNSYM y SHT_SYMTAB, uno más que el índice del último símbolo local |
sh_addralign |
0x30 | 8 | Elf64_Xword |
Alineación |
sh_entsize |
0x38 | 8 | Elf64_Xword |
Tamaño de cada entrada, si la sección es una tabla: 24 en .dynsym, 16 en .dynamic |
.dynsym es la sección de tipo SHT_DYNSYM: su sh_link lleva a .dynstr, y
sh_size / sh_entsize es su número de símbolos.
Elf64_Sym: 24 bytes por símbolo. La entrada 0 es nula (STN_UNDEF).
| Campo | Offset | Tamaño | Tipo | Significado |
|---|---|---|---|---|
st_name |
0x00 | 4 | Elf64_Word |
Offset del nombre en la tabla de cadenas; 0, sin nombre |
st_info |
0x04 | 1 | unsigned char |
Vinculación en los 4 bits altos —STB_LOCAL = 0, STB_GLOBAL = 1, STB_WEAK = 2— y tipo en los 4 bajos —STT_NOTYPE = 0, STT_OBJECT = 1, STT_FUNC = 2— |
st_other |
0x05 | 1 | unsigned char |
Visibilidad en los 2 bits bajos: STV_DEFAULT = 0, STV_HIDDEN = 2 |
st_shndx |
0x06 | 2 | Elf64_Half |
Sección que lo define; SHN_UNDEF = 0 en un símbolo importado |
st_value |
0x08 | 8 | Elf64_Addr |
En un .so, la dirección virtual del símbolo |
st_size |
0x10 | 8 | Elf64_Xword |
Tamaño en bytes |
Un Java_* exportado es STB_GLOBAL y STT_FUNC —st_info = 0x12— con st_shndx distinto
de 0; una función importada de libc lleva el mismo st_info y st_shndx = 0.
Elf64_Dyn: 16 bytes por entrada. .dynamic es un array de ellas que termina en DT_NULL.
| Campo | Offset | Tamaño | Tipo | Significado |
|---|---|---|---|---|
d_tag |
0x00 | 8 | Elf64_Sxword |
Qué es la entrada |
d_un |
0x08 | 8 | Elf64_Xword / Elf64_Addr |
d_val, un número, o d_ptr, una dirección virtual, según d_tag |
d_tag |
Valor | d_un |
Contenido |
|---|---|---|---|
DT_NULL |
0 | — | Fin del array |
DT_NEEDED |
1 | d_val |
Offset en DT_STRTAB del nombre de una dependencia |
DT_HASH |
4 | d_ptr |
Tabla hash de System V |
DT_STRTAB |
5 | d_ptr |
Tabla de cadenas, .dynstr |
DT_SYMTAB |
6 | d_ptr |
Tabla de símbolos, .dynsym |
DT_STRSZ |
10 | d_val |
Tamaño de DT_STRTAB |
DT_SYMENT |
11 | d_val |
Tamaño de un símbolo: 24 en ELF64 |
DT_SONAME |
14 | d_val |
Offset en DT_STRTAB del nombre de la propia biblioteca |
DT_TEXTREL |
22 | — | Hay relocalizaciones que escriben en segmentos no escribibles («sección 6.5 · Qué rechaza el cargador») |
DT_FLAGS |
30 | d_val |
Banderas DF_*; DF_TEXTREL = 0x4 sustituye a DT_TEXTREL |
DT_GNU_HASH |
0x6ffffef5 |
d_ptr |
Tabla hash de GNU |
DT_GNU_HASH no está en el gABI. Su disposición es la que lee el cargador de bionic al
cargar la biblioteca y al buscar un símbolo (linker.cpp, líneas 2938-2965, y gnu_lookup en
linker_soinfo.cpp, líneas 300-338, en android-17.0.0_r1), con los nombres de campo de bionic:
| Offset | Tamaño | Campo | Contenido |
|---|---|---|---|
| 0x00 | 4 | nbucket |
Número de cubetas |
| 0x04 | 4 | symndx |
Índice del primer símbolo que entra en la tabla; los anteriores no están |
| 0x08 | 4 | maskwords |
Palabras del filtro de Bloom. Si no es potencia de 2, el cargador rechaza la biblioteca |
| 0x0C | 4 | shift2 |
Desplazamiento del segundo bit que se mira en el filtro |
| 0x10 | maskwords × 8 |
filtro de Bloom | Palabras de 8 bytes en ELF64 y de 4 en ELF32 |
| … | nbucket × 4 |
cubetas | Por cubeta, el índice del primer símbolo de su cadena, o 0 si está vacía |
| … | 4 por símbolo | cadenas | Un valor por cada símbolo desde symndx: su hash, con el bit 0 como marca de fin de cadena |
DT_SYMTAB no dice cuántos símbolos hay. Con DT_HASH lo dice su segunda palabra, nchain, que
según el gABI es igual al número de símbolos. Con DT_GNU_HASH hay que deducirlo: se toma la mayor
de las cubetas, se avanza por las cadenas desde ese índice hasta el primer valor con el bit 0 a 1,
y ese índice más uno es el número de símbolos; si todas las cubetas valen 0, es symndx.
Una .so puede traer una de las dos tablas hash o las dos. Lo más común es que traiga las dos
(dos de cada tres .so de F-Droid). En el mercado chino la tabla antigua pesa más: el 43 % de sus
.so solo traen DT_HASH, frente al 8 % en F-Droid. Las que solo traen DT_GNU_HASH rondan una
de cada cuatro en F-Droid y en Play, y apenas el 4 % en el mercado chino. libtermux.so de Termux
trae las dos: nchain de DT_HASH vale 38 y coincide con los 38 símbolos que salen de
DT_GNU_HASH (abajo).
Qué pasa con una .so que solo trae DT_GNU_HASH en una app con minSdk bajo no lo hemos
encontrado en ninguna fuente, así que este documento no da el número de API desde el que
bionic la lee. El caso existe: entre las apps con minSdk menor que 23, alguna .so con solo
DT_GNU_HASH aparece en pocas de F-Droid (12 de 576), pero en 26 de 62 del mercado chino.
La vía PT_DYNAMIC. Sin fiarse de la tabla de secciones, los símbolos se leen así:
- Se busca el
program headerPT_DYNAMIC(«sección 3.4 · program header») y se recorren desde sup_offsetlosElf64_DynhastaDT_NULL. - Se toman
DT_STRTAB,DT_SYMTAByDT_GNU_HASH—oDT_HASH—. Son direcciones virtuales, no offsets: se pasan a offset con elPT_LOADque las contiene,p_offset + (d_ptr − p_vaddr). - Se cuenta el número de símbolos por la tabla hash, como arriba, y se leen los
Elf64_Symde 24 en 24 desdeDT_SYMTAB, con los nombres enDT_STRTAB.
Es lo que hace el propio cargador: bionic localiza la tabla dinámica por PT_DYNAMIC y resuelve
los símbolos con DT_SYMTAB, DT_STRTAB y la tabla hash, no con las secciones (prelink_image,
linker.cpp, líneas 2881-2985 y 3322-3334). Pero el cargador de android-17.0.0_r1 exige además
la tabla de secciones: rechaza el .so que no la trae, con has no section headers, o cuyo
e_shoff no cae dentro del fichero (linker_phdr.cpp, líneas 391-405), y busca en ella la sección
SHT_DYNAMIC para contrastarla con PT_DYNAMIC (líneas 417-478). Así que una .so que ese
sistema carga la tiene, aunque de su contenido el cargador use poco: la sección SHT_DYNAMIC y la
tabla de cadenas a la que apunta y, en el modo de compatibilidad de 16 KiB de la «sección 6.1 · Qué es el requisito», el
sh_flags y el sh_addralign de todas las secciones SHF_ALLOC. Con la mayor de esas
alineaciones decide si puede desplazar la carga para separar el código de los datos escribibles;
si no puede, avisa con RX|RW compat loading failed y deja la biblioteca entera en rwx
(get_max_section_alignment, linker_phdr_16kib_compat.cpp, líneas 92-102, usada en 219-226;
Setup16KiBAppCompat y SetupRWXAppCompat, 392-416). Uno con e_shoff = 0, que el gABI admite
para un fichero sin tabla de secciones, no lo abre dlopen, pero sus símbolos se siguen leyendo
por esta vía.
Pero el muestrario trae ELF que no la tienen. En lib/<abi>/ hay 174 con la tabla anómala: los
150 ET_EXEC (ejecutables sin SHT_DYNAMIC) y 24 ET_DYN. De estos 24, 16 no tienen e_shoff, 5
tienen la tabla fuera del fichero y 3 no tienen sección SHT_DYNAMIC. Están en 11 apps, todas con
targetSdk 26 o más. Fíjate en de quién son: por su nombre, parecen sobre todo de SDK antifraude
de apps de Google Play: libPhoenixAndroid.so y
libRecogKitAndroid.so (Tinder, Nubank, PayPal, iFood) y libfacevalidation-native-lib.so
(Mercado Libre y Mercado Pago), sin e_shoff; libjni_signal.so (OPPO Music y HeyTap Music), con
la tabla fuera del fichero. No hemos identificado el SDK en el código. Ejemplos:
libPhoenixAndroid.so,lib/arm64-v8a/,ET_DYNde 64 bits sine_shoff: la piezaconfig.arm64_v8a.apkdel.xapkde Tinder 17.40.0 (targetSdk36).libjni_signal.so, tabla de secciones fuera del fichero: la piezasplit_config.arm64_v8a.apkdel.apkmde OPPO Music (com.oppo.music, 58.15.1.58.5).libshella-4.6.2.2.so(Tencent Legu), tabla fuera del fichero:com.tencent.tgclub(tienda 360,targetSdk34).libmstype_x.so, sinSHT_DYNAMIC:com.yitong.mbank.psbc(tienda 360,targetSdk30).
Con una tabla así, el cargador de android-17.0.0_r1 rechazaría la .so con has no section headers o has invalid shdr offset/size («sección 6.5 · Qué rechaza el cargador»). No lo hemos probado en un dispositivo con
Android 17. Que esas apps funcionen hoy es coherente con que las versiones anteriores sean menos
estrictas, pero eso no lo hemos medido. Los 3 ELF de más de 256 MiB se leyeron en parte y no cuentan
como anomalía lo que quedó sin leer.
Sobre libtermux.so (el de la «sección 8.2 · Extraer una .so y leer su cabecera con xxd») de Termux, recorrido el 31 de octubre de 2026 con el
lector de esta documentación, que solo lee los bytes de la .so y no la carga
(MUESTRARIO_RAIZ=<raíz> python3 -I scripts/muestrario/cifras/nativo_1.py --recorrido <lib.so>).
De las 27 entradas de .dynamic se omiten las de relocalización y versionado:
PT_DYNAMIC p_offset 0x19d8 p_vaddr 0x29d8 p_filesz 0x1b0 (27 Elf64_Dyn)
DT_NEEDED 0x1c8 → libc.so
DT_NEEDED 0x1d5 → libm.so
DT_NEEDED 0x1dd → libstdc++.so
DT_NEEDED 0x1ea → libdl.so
DT_SONAME 0x1f3 → libtermux.so
DT_FLAGS 0x8
DT_SYMTAB 0x2c0 → offset 0x2c0, en el primer PT_LOAD (p_offset 0, p_vaddr 0)
DT_SYMENT 0x18
DT_STRTAB 0x828 → offset 0x828
DT_STRSZ 0x200
DT_GNU_HASH 0x6c0 → nbucket 1, symndx 33, maskwords 1, shift2 26 → 38 símbolos
DT_HASH 0x6f0 → nchain 38
DT_NULL
sym[33] Java_com_termux_terminal_JNI_close st_info 0x12 st_shndx 14 st_value 0x179c st_size 0x8
sym[34] Java_com_termux_terminal_JNI_createSubprocess st_info 0x12 st_shndx 14 st_value 0x1020 st_size 0x6a0
…
El PT_DYNAMIC está en el offset 0x19d8 pero en la dirección 0x29d8: el segundo PT_LOAD
mapea el offset 0x19c0 en 0x29c0, y por eso las direcciones no se pueden usar como offsets sin
convertirlas. Los 38 símbolos coinciden con sh_size / sh_entsize de la .dynsym de la misma
biblioteca (0x390 / 24) y con el nchain de DT_HASH. Del 1 al 32 son importaciones
(st_shndx = 0) y quedan por debajo de symndx; del 33 al 37 son los cinco Java_* de la
«sección 4.2 · Vía A: descubrimiento por nombre (dlsym)», en .text, que es la sección número 14 del fichero.
En ELF32 cambian los tamaños y, en los símbolos, el orden: Elf32_Shdr mide 40 bytes, con los
mismos campos en el mismo orden y todos de 4 bytes; Elf32_Sym mide 16, con st_name en 0x00,
st_value en 0x04, st_size en 0x08, st_info en 0x0C, st_other en 0x0D y st_shndx en
0x0E; y Elf32_Dyn mide 8, con d_tag en 0x00 y d_un en 0x04.
3.7 Ficheros raros dentro de lib/
No todo lo que se llama lib…so es un ELF o una biblioteca. En el muestrario hay tres casos.
- Ficheros que no son ELF. 2.779 ficheros de
lib/<abi>/no empiezan por la firma\x7fELF(7f 45 4c 46). Fuera del mercado chino son raros; allí aparecen en 37 de cada 100 apps. El tipo lo da la lectura de los primeros bytes de unos ejemplos; la cifra no clasifica el contenido. Algunos son datos de un SDK, a juzgar por el nombre: en DingTalk (com.alibaba.android.rimet, tienda 360),libsgmain.so(110.987 B) es un ZIP ylibsgmainso.version.so(10 B) un texto con la versión. Otros son paquetes:libpybundle.sodeorg.lufebe16.pysolfces ungzipde 13.630.940 B, ylibpython.zip.sodecom.myAllVideoBrowseres un ZIP.lib_execInProot.sh.sodecom.puutaro.commandclick(IzzyOnDroid) es un script de shell. - ELF con un paquete dentro.
libtermux-bootstrap.sode Termux es un ELF válido de 29.392.992 B que lleva un ZIP incrustado a partir del offset 1.328 y exportaJava_com_termux_app_TermuxInstaller_getZip. - ELF de otra arquitectura o ejecutables.
.sode x86-64 enlib/arm64-v8a/(«sección 3.3 · e_machine por ABI») y ejecutables con nombre de biblioteca («sección 3 · Estructura mínima de un ELF compartido»).
Un inventario que dé por hecho que todas las .so son ELF falla en estos casos. Antes de leer una
.so, comprueba los cuatro primeros bytes.
4. JNI: cómo se enlaza un método nativo
Un método declarado native en Java no tiene cuerpo en el DEX. En el momento de la primera
llamada, ART tiene que encontrar la función en C que le corresponde. Hay dos vías, y la
diferencia entre ellas decide si el análisis estático es trivial o es un problema.
4.1 Cargar la biblioteca
Desde un inicializador estático de la clase, con System.loadLibrary("fubar"): «the argument
is the "undecorated" library name, so to load libfubar.so you would pass in "fubar"». El
.so sale de lib/<abi>/ del APK instalado, o del directorio al que el instalador lo
extrajo («sección 5 · extractNativeLibs y lo que implica para el ZIP»). Pero una app también puede llevar ELF en otros sitios y cargarlos con
System.load. Un inventario que solo mire lib/ se los salta. En F-Droid y en Play es poco
habitual (un 5 % de las más instaladas), pero en el mercado chino lo hacen 79 de cada 100 apps.
Muchos son binarios con nombre extraño dentro de assets/, como assets/libwbsafeedit (17.636 B)
o assets/libunisec_x86_64.so (1.238.720 B), que suelen ser comprobaciones de seguridad o
cargadores. Ejemplos, los dos del mercado chino: com.tencent.tmgp.aceracer y
com.tencent.tmgp.yyslscn.
En assets/ también se esconde código que no es nativo. Fíjate en Play más instaladas: el 39 %
lleva algún .dex, .jar, .apk, .odex, .vdex u .oat ahí. Muchas veces es
assets/audience_network.dex, de Meta, de unos 3 a 5 MB (por ejemplo, 8 Ball Pool 56.33.0, con
5.017.908 B). Los ficheros comprimidos (.xz, .zst, .spk, .7z, .br o .lz4) en
assets/ son más raros, salvo en el mercado chino (12 de 100).
4.2 Vía A: descubrimiento por nombre (dlsym)
Si el símbolo exportado sigue una convención de nombres, el runtime lo encuentra solo:
«A native method name is concatenated from the following components: the prefix
Java_; a mangled fully-qualified class name; an underscore ("_") separator; a mangled method name; for overloaded native methods, two underscores ("__") followed by the mangled argument signature.»
La barra del nombre cualificado se sustituye por _, y como ni un nombre ni un descriptor
empiezan por número, los dígitos quedan libres para escapes: _0XXXX es el carácter Unicode
XXXX en minúsculas (_0abcd, no _0ABCD), _1 es _, _2 es ; y _3 es [. La
signatura solo se añade cuando el método está sobrecargado: «The VM looks first for the short
name… It then looks for the long name».
Esto es un regalo para el análisis: el nombre del símbolo contiene el paquete, la clase y
el método Java a los que corresponde. En libtermux.so de Termux, .dynsym trae
Java_com_termux_terminal_JNI_close, …_createSubprocess, …_setPtyUTF8Mode,
…_setPtyWindowSize y …_waitFor: sin abrir el desensamblador ya se sabe que
com.termux.terminal.JNI tiene cinco métodos nativos y cuál es cada uno.
4.3 Vía B: RegisterNatives desde JNI_OnLoad
La otra vía es registrar la correspondencia en tiempo de ejecución, con una tabla de punteros a función:
JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
// … obtener JNIEnv* env y jclass c = env->FindClass("com/example/MyClass") …
static const JNINativeMethod methods[] = {
{"nativeFoo", "()V", reinterpret_cast<void*>(nativeFoo)},
{"nativeBar", "(Ljava/lang/String;I)Z", reinterpret_cast<void*>(nativeBar)},
};
env->RegisterNatives(c, methods, sizeof(methods)/sizeof(JNINativeMethod));
return JNI_VERSION_1_6;
}
Y es lo que Google recomienda, por motivos ajenos a la ofuscación: «Most apps should call
RegisterNatives() from JNI_OnLoad(). […] Mistakes are caught early. An incorrectly named
function will cause an error during library load. The only symbol that typically must be
exported is JNI_OnLoad()», y «build with a version script (preferred) or use
-fvisibility=hidden so that only your JNI_OnLoad is exported from your library».
4.4 Por qué RegisterNatives complica el análisis estático
Con la vía A la correspondencia entre método Java y función nativa está en la tabla de
símbolos, que es un dato estático. Con la vía B está en el argumento de una llamada que
solo ocurre en tiempo de ejecución, y recuperarla exige localizar JNI_OnLoad en .text,
seguir el flujo hasta la llamada a RegisterNatives —que es indirecta, a través de la tabla
de funciones de JNIEnv—, y reconstruir el array JNINativeMethod[], normalmente en
.rodata, con sus tres campos: nombre, descriptor de firma y puntero a la implementación. Si
el nombre y el descriptor se construyen o se descifran en ejecución, no queda nada estático
que reconstruir.
El resultado se ve de un vistazo. libandroidx.graphics.path.so de F-Droid Client exporta un solo
símbolo propio:
00000000000016c8 g DF .text 00000000000001c0 LIBANDROIDX.GRAPHICS.PATH JNI_OnLoad
Ni un Java_*. Todo lo demás en .dynsym son siete importaciones de libc. Esta .so es una
pieza de Jetpack que viene en más de la mitad de las apps con código nativo de F-Droid, no código
de la app: conviene reconocerla por su nombre antes de entrar al desensamblador («sección 4.5 · Reconocer marcos y bibliotecas por el nombre de sus .so»).
El criterio de triaje sirve para empezar, no para decidir. Si .dynsym trae símbolos
Java_*, el mapa está servido. Si solo trae JNI_OnLoad, hay que entrar al desensamblador. Si no
trae ninguno de los dos, la .so no es un puente JNI, o se carga por otra vía.
Cuánto toca desensamblar depende mucho de dónde venga la app. Entre las .so propias (nombre en
menos de 3 apps), solo exportan JNI_OnLoad el 4 % en F-Droid, pero el 23 % en Google Play más
instaladas y el 28 % en el mercado chino.
Ojo con «ninguno de los dos»: no basta para sospechar de un protector. En F-Droid, el 62 % de las
.so propias no exportan ni Java_* ni JNI_OnLoad, y entre todas las .so las que más se
repiten sin ellos son dependencias corrientes, como libapp.so de Flutter o libc++_shared.so.
Una biblioteca que no es un puente JNI es lo normal; la señal de un protector son otros rasgos
(«sección 4.6 · Protectores vistos desde el ELF»). «Propia» y «conocida» son
aproximaciones por el nombre del fichero, y comprobar si una .so que solo exporta JNI_OnLoad
usa RegisterNatives exige desensamblarla.
4.5 Reconocer marcos y bibliotecas por el nombre de sus .so
Antes de abrir un desensamblador, mira cómo se llaman las .so. Muchas no son código de la app,
sino un marco (Flutter, Unity, React Native…) o una biblioteca de terceros. El nombre del fichero
dice casi siempre cuál, y qué hay que analizar.
Tabla de marcos. Cada celda es el número de apps con alguna prueba fuerte (una .so, una entrada
de assets/ o una clase del DEX), sobre todas las apps del grupo:
| Marco | F-Droid | IzzyOnDroid | Google Play más instaladas | Google Play sorteo | Mercado chino | Webs de autores |
|---|---|---|---|---|---|---|
libflutter.so y libapp.so (Flutter) |
509 de 4.766 · 11 % | 148 de 1.402 · 11 % | 33 de 658 · 5 % | 66 de 369 · 18 % | 17 de 100 | 0 de 7 |
libunity.so y libil2cpp.so (Unity) |
0 de 4.766 | 0 de 1.402 | 110 de 658 · 17 % | 84 de 369 · 23 % | 13 de 100 | 1 de 7 |
libreactnative.so, libreactnativejni.so, libhermes.so (React Native) |
96 de 4.766 · 2 % | 14 de 1.402 · 1 % | 50 de 658 · 8 % | 37 de 369 · 10 % | 25 de 100 | 0 de 7 |
libUE4.so (Unreal Engine) |
0 de 4.766 | 0 de 1.402 | 3 de 658 | 0 de 369 | 0 de 100 | 0 de 7 |
libgodot_android.so (Godot) |
40 de 4.766 · 1 % | 0 de 1.402 | 1 de 658 | 4 de 369 | 0 de 100 | 0 de 7 |
libgdx.so (libGDX) |
41 de 4.766 · 1 % | 0 de 1.402 | 6 de 658 · 1 % | 0 de 369 | 3 de 100 | 0 de 7 |
libcocos*.so (Cocos2d-x) |
0 de 4.766 | 0 de 1.402 | 23 de 658 · 3 % | 10 de 369 · 3 % | 6 de 100 | 0 de 7 |
libgojni.so (Go, gomobile) |
51 de 4.766 · 1 % | 4 de 1.402 | 7 de 658 · 1 % | 0 de 369 | 1 de 100 | 0 de 7 |
libmonodroid.so, libxamarin-app.so (.NET para Android) |
0 de 4.766 | 9 de 1.402 · 1 % | 1 de 658 | 1 de 369 | 0 de 100 | 0 de 7 |
libQt*Core*.so (Qt) |
15 de 4.766 | 7 de 1.402 | 2 de 658 | 1 de 369 | 0 de 100 | 0 de 7 |
libSDL2.so, libSDL3.so (SDL) |
46 de 4.766 · 1 % | 3 de 1.402 | 4 de 658 | 1 de 369 | 0 de 100 | 0 de 7 |
| Flutter, Unity o React Native | 605 de 4.766 · 13 % | 162 de 1.402 · 12 % | 193 de 658 · 29 % | 187 de 369 · 51 % | 52 de 100 | 1 de 7 |
| Alguno de los 22 marcos que dejan la lógica fuera del DEX | 814 de 4.766 · 17 % | 222 de 1.402 · 16 % | 236 de 658 · 36 % | 222 de 369 · 60 % | 67 de 100 | 1 de 7 |
Lo que importa de la tabla es la última fila: en el sorteo de Play, seis de cada diez apps tienen
algún marco que deja la lógica fuera del DEX. Flutter es el más frecuente en F-Droid, y Unity,
que no aparece en F-Droid ni en IzzyOnDroid, el más repartido en Google Play. Las dos últimas
filas son cifras distintas: «Flutter, Unity o React Native» agrupa tres marcos; la última, los 22
marcos que reconoce el medidor. Con Flutter, la lógica está en libapp.so, un volcado compilado de
Dart. Con Unity, en libil2cpp.so y en un fichero global-metadata.dat. Con React Native, en un
fichero index.android.bundle. En los tres casos un decompilador a Java solo ve el cargador.
Un ejemplo de cada marco:
- Flutter:
libflutter.soylibapp.soenace.software.pocketsense(F-Droid). - Unity:
libunity.so(23.104.696 B) en elsplit_config.arm64_v8a.apkdel.apkmdecom.olzhas.carparking.multyplayer4.9.11, ylibunity.sode 263.201.040 B encom.tencent.tmgp.cod(mercado chino). - React Native:
libreactnative.so(6.763.936 B) ennet.aliasvault.app(F-Droid). - Unreal:
lib/arm64-v8a/libUE4.so(252.290.584 B sin comprimir) en PUBG Mobile 4.6.0 (APKPure). - Godot:
libgodot_android.so(152.655.560 B) enorg.godotengine.editor.v4(F-Droid). - libGDX:
libgdx.soencom.miloshpetrov.sol2.android(F-Droid). - Go (gomobile):
libgojni.so(32.309.568 B) enorg.irmacard.cardemu(F-Droid). - .NET para Android:
libxamarin-app.soench.martinstoeckli.silentnotes(IzzyOnDroid).
Bibliotecas más repetidas, por nombre de fichero. Cada celda es el número de apps con esa .so
entre las apps con código nativo del grupo (F-Droid 2.709, IzzyOnDroid 820, Play más instaladas 615,
sorteo de Play 311, mercado chino 100). «–» quiere decir que no está entre las 25 primeras del grupo, y
la pasada no da su cifra:
| Biblioteca | F-Droid | IzzyOnDroid | Play más instaladas | Play sorteo | Mercado chino |
|---|---|---|---|---|---|
libandroidx.graphics.path.so |
1.387 · 51 % | 451 · 55 % | 252 · 41 % | 44 · 14 % | – |
libdatastore_shared_counter.so |
951 · 35 % | 297 · 36 % | 329 · 53 % | 156 · 50 % | – |
libc++_shared.so |
278 · 10 % | 59 · 7 % | 194 · 32 % | 82 · 26 % | 80 de 100 |
libflutter.so |
509 · 19 % | 148 · 18 % | – | 66 · 21 % | – |
libapp.so |
506 · 19 % | 148 · 18 % | – | 66 · 21 % | – |
libimage_processing_util_jni.so |
238 · 9 % | 46 · 6 % | 149 · 24 % | – | 23 de 100 |
libsurface_util_jni.so |
203 · 7 % | 42 · 5 % | 125 · 20 % | – | – |
libimagepipeline.so |
103 · 4 % | 20 · 2 % | 74 · 12 % | 38 · 12 % | 44 de 100 |
libnative-filters.so |
98 · 4 % | 20 · 2 % | 73 · 12 % | 38 · 12 % | 41 de 100 |
libsqlcipher.so |
90 · 3 % | – | – | – | – |
libsqlite3.so |
89 · 3 % | 27 · 3 % | – | – | – |
libconscrypt_jni.so |
77 · 3 % | 18 · 2 % | – | – | – |
libjnidispatch.so |
71 · 3 % | 15 · 2 % | – | – | – |
libcrashlytics.so |
– | – | 161 · 26 % | 38 · 12 % | – |
libapplovin-native-crash-reporter.so |
– | – | 172 · 28 % | 55 · 18 % | – |
libapminsighta.so |
– | – | 165 · 27 % | 48 · 15 % | – |
libmmkv.so |
– | – | 77 · 13 % | – | 56 de 100 |
Las dos más repetidas en F-Droid, libandroidx.graphics.path.so y libdatastore_shared_counter.so,
son piezas pequeñas de Jetpack. En Google Play más instaladas dominan las de informes de fallos y
anuncios (libcrashlytics*.so, libapminsight*.so, libapplovin-native-crash-reporter.so). Si
una .so tiene un nombre de esta tabla, no es código propio de la app. La atribución de un nombre
a un fabricante concreto sale solo del nombre.
4.6 Protectores vistos desde el ELF
Un protector (o packer) cifra o esconde el código de la app y lo descifra al ejecutarla. Desde
fuera, deja huellas en lib/: nombres de .so conocidos y rarezas en el formato. El análisis de
estas protecciones está en «Packers y protectores».
Las familias más repetidas del muestrario, por el nombre de su .so. Es la heurística por nombres
de .so, de entrada o de clase del DEX (no la lista de APKiD), y atribuir una .so a un
fabricante sale del nombre, no de un análisis del contenido:
| Familia | .so típicas en lib/ |
Apps del mercado chino (de 100) | Apps de Play más instaladas (de 658) |
|---|---|---|---|
| Bangcle/SecNeo | libDexHelper.so, libDexHelper-x86.so |
21 | 0 |
| Ijiami | libexecmain.so, libijmDataEncryption.so |
7 | 0 |
| NetEase | libnesec.so, libnesec-x86.so |
4 | 1 |
| Jiagu 360 | libjiagu.so, libjiagu_a64.so, libjiagu_vip.so |
2 | 0 |
| Naga | libxloader.so |
2 | 0 |
| Tencent Legu | libshella-*.so, libshell-super*.so |
1 | 0 |
| DexProtector | libdexprotector.so |
0 | 6 |
En el mercado chino, 38 de las 100 apps llevan alguna familia reconocida por nombre; en Google Play
más instaladas, 12 de 658 (2 %); en el sorteo de Play, 1 de 369; y ninguna en F-Droid ni en
IzzyOnDroid. PairIP (libpairipcore.so), la protección de Google Play, se cuenta aparte: 45 de 658
en Play más instaladas (7 %).
Las rarezas de formato que acompañan a los protectores:
- Algún fichero de
lib/que no es ELF: 13 de las 38 apps empaquetadas del mercado chino, frente a 24 de las 62 que no lo están. El dato no separa a los protegidos por sí solo. - ELF de otra arquitectura en la carpeta de otra:
libDexHelper-x86.soestá enlib/arm64-v8a/comoEM_X86_64encn.cj.pe(«sección 3.3 · e_machine por ABI»). - Tabla de secciones fuera del fichero en
libshella-4.6.2.2.so(Tencent Legu) decom.tencent.tgclub(«sección 3.6 · Secciones, símbolos y tabla dinámica»). Con la tabla de secciones anómala hay 2 de las 12 empaquetadas de Play más instaladas y 2 de las 38 del mercado chino. - Más constructores en
.init_array: mediana de 4 punteros frente a 0 («sección 3.5 · Secciones que importan al analizar»).
El DEX que se ve en una app protegida es pequeño, porque es el cargador: en el mercado chino, la
mediana de clases en el DEX visible es de 27,5 en las 38 empaquetadas y de 61.377,5 en las 62
demás.
5. extractNativeLibs y lo que implica para el ZIP
«This attribute indicates whether the package installer extracts native libraries from the APK to the file system. If set to
"false", your native libraries are stored uncompressed in the APK. Although your APK might be larger, your application loads faster because the libraries load directly from the APK at runtime.»
| Valor | En el ZIP | En el dispositivo |
|---|---|---|
true |
.so en deflate, sin restricción de alineación |
El instalador los descomprime a disco: dos copias |
false |
.so en stored y alineados |
Se mapean con mmap(2) desde el APK: una copia. En un dispositivo de 16 KB con la .so a 4 KiB, Android 16 la extrae —dos copias— y, si el ELF es de 4 KB, la copia entera a memoria anónima («sección 6.4 · Qué pasa en el dispositivo») |
Desde AGP 3.6 el valor por defecto es "false" —«the plugin now sets extractNativeLibs to
"false" by default. That is, your native libraries are page aligned and packaged
uncompressed»— y desde AGP 4.2 se configura por DSL con useLegacyPackaging.
La guía dice que «the default value of extractNativeLibs depends on minSdkVersion and the
version of AGP you're using», y el umbral está en la referencia de la DSL:
JniLibsPackaging.useLegacyPackaging —«If null, .so files will be uncompressed and page-aligned
when minSdk >= 23»—.
En un APK compilado el atributo suele aparecer escrito, y si vale false las .so van siempre
sin comprimir. Lo normal es false: lo llevan unas dos de cada tres apps con código nativo de
F-Droid, IzzyOnDroid y el sorteo de Play, y algo más de la mitad en Play más instaladas. El mercado
chino va al revés: allí casi nadie lo pone (4 de 100), 59 declaran true y 37 no llevan el
atributo.
Lo que el instalador rechazaría no aparece: ninguna app con false lleva una .so comprimida ni
una .so sin comprimir fuera de múltiplo de 4.096. Si el atributo falta, la documentación dice
que el valor depende de minSdk y de la versión de AGP, pero los APK ya compilados no siguen esa
regla. De las 18 apps de F-Droid con el atributo ausente y minSdk 23 o más, las 18 llevan las
.so comprimidas; en Play más instaladas, 5 de 7. Con true y todas las .so sin comprimir solo
hay 17 apps de Play más instaladas (3 %). Es una rareza en la que la .so no se mapea desde el
APK, como en la pieza
base.apk del .apkm de Google Fit (com.google.android.apps.fitness, 2026.09.24.00,
armeabi-v7a). Desde el APK no se puede saber si un false lo escribió el desarrollador o lo puso
la herramienta de compilación.
Contraste medido en el muestrario con aapt2 dump xmltree y unzip -v:
| APK | targetSdk |
extractNativeLibs |
Método ZIP de las .so |
|---|---|---|---|
Termux (com.termux, versión 1022) |
28 | true |
Defl:N |
Tuta (de.tutao.tutanota, versión 396715) |
36 | false |
Stored, alineado a 16 KiB |
Consecuencia al modificar un APK: si extractNativeLibs es false, reempaquetar un .so
comprimiéndolo impide instalar el APK. El instalador lo rechaza con
INSTALL_FAILED_INVALID_APK: Failed to extract native libraries, res=-2, y en logcat queda
«Library '…' is compressed - will not be able to open it directly from apk». Lo que pasa cuando
la .so va sin comprimir pero su offset en el ZIP no es múltiplo de la página —el rechazo de
Android 15, la extracción de rescate de Android 16, cómo se impide y la marca pageSizeCompat=2—
es cosa del contenedor y está en la «sección 3 de
Alineación y zipalign · La regla de las páginas de 16 KiB»; si la .so se extrae, la
aplicación carga esa copia, que va antes que base.apk!/lib/arm64-v8a en la ruta de búsqueda. El
relleno que alinea está en la «sección 8.1 de Contenedor ZIP · El extra field como relleno de alineación», y la matriz
medida de ELF y ZIP, en la «sección 6.4 · Qué pasa en el dispositivo».
5.1 Cuánto pesan las .so y cuánto ahorra comprimirlas
La documentación de Android dice que, con extractNativeLibs="false", el APK puede ser más grande.
Aquí miramos cuántas .so van de cada manera y cuánto ahorra el método deflate cuando se usa.
Una comparación exacta del tamaño exigiría las mismas .so guardadas de las dos maneras, y el
muestrario no la da. La tabla cuenta ficheros .so de lib/<abi>/ de todas las piezas de las apps
de cada grupo. La última columna es la razón entre los bytes que ocupan en el ZIP y los bytes
originales, solo de las que van comprimidas, calculada sobre la suma de todas (no es la media de
las razones de cada fichero):
| Grupo | .so sin comprimir en el ZIP |
.so comprimidas |
Comprimidas: bytes en el ZIP / bytes originales |
|---|---|---|---|
| F-Droid | 17.366 | 21.351 | 0,40 |
| IzzyOnDroid | 3.700 | 3.635 | 0,43 |
| Play más instaladas | 11.520 | 12.594 | 0,37 |
| Play sorteo | 2.418 | 1.676 | 0,32 |
| Mercado chino | 211 | 9.528 | 0,38 |
| Webs de autores | 12 | 146 | 0,41 |
Las .so que van comprimidas ocupan en el ZIP entre un tercio y dos quintos de su tamaño original
(de 0,32 en el sorteo de Play a 0,43 en IzzyOnDroid). Las más grandes pasan de 190 MB. Estos son
sus tamaños sin comprimir y, donde se mide, dentro del ZIP:
libqnmessage.so: 441.767.808 B y 90.848.171 B en el ZIP, encom.taobao.qianniu(tienda 360).libminecraftpe.so: 321.838.032 B y 97.382.109 B, en elconfig.arm64_v8a.apkdel.xapkde Minecraft Trial 1.26.52.3.libil2cpp.so: 285.714.696 B y 76.582.246 B, encom.tencent.jkchess(mercado chino).libunity.so: 263.201.040 B y 94.964.074 B («sección 4.5 · Reconocer marcos y bibliotecas por el nombre de sus .so»).libUE4.so: 252.290.584 B y 77.221.575 B («sección 4.5 · Reconocer marcos y bibliotecas por el nombre de sus .so»).libsimplex.so: 197.610.624 B, condeflate, en SimpleX Chat (chat.simplex.app, versión 385).
6. Páginas de 16 KB
6.1 Qué es el requisito
Android ha usado siempre páginas de memoria de 4 KB. A partir de Android 15 hay dispositivos
con páginas de 16 KB, y en ellos un binario cuyos segmentos PT_LOAD estén alineados a 4 KB
no se puede mapear tal cual. Qué pasa entonces depende de la versión. El Android 15 de salida no
lo comprueba y lo mapea mal: el fallo llega después, con un mensaje que no habla de alineación.
Desde Android 15 QPR1, según el código, el cargador lo rechaza con «"…" program alignment (4096)
cannot be smaller than system page size (16384)». Y Android 16 añade un modo de
compatibilidad: el instalador detecta los PT_LOAD con p_align de 4 KB, marca la
aplicación, y el cargador, en vez de mapear la .so, la copia a memoria anónima. Cuesta RAM
—ninguna página se comparte— y deja ejecutables los datos de solo lectura: como los permisos solo
se pueden poner por páginas de 16 KB, el cargador copia los segmentos a una reserva anónima y
protege como r-x, de una vez, todo lo que va antes de los datos escribibles —.text, pero
también .rodata y la zona RELRO— (Setup16KiBAppCompat en linker_phdr_16kib_compat.cpp y
phdr_table_protect_gnu_relro_16kib_compat en linker_phdr.cpp, android-16.0.0_r1). El usuario
ve un aviso al abrir la aplicación. El atributo android:pageSizeCompat del manifiesto, con los valores
"enabled" o "disabled", fuerza el modo en un sentido u otro; en Android 16 fijarlo quita el
aviso, y en Android 17, según el código, el aviso sale igual si hay .so desalineadas. Todo esto
está ejecutado en la «sección 6.4 · Qué pasa en el dispositivo». La condición se comprueba sobre p_align:
«Check the output lines to ensure that the load segments don't have values less than
2**14. If any load segments are2**13,2**12, or lower values, you'll need to update the packaging»
2**14 = 16.384 = 0x4000. Son dos alineaciones distintas y ambas obligatorias:
| Dónde | Qué se alinea | Cómo se comprueba |
|---|---|---|
Dentro del .so |
p_align de cada segmento PT_LOAD ≥ 0x4000 |
objdump -p / readelf -l |
| Dentro del APK | Offset de los datos de cada entrada .so stored |
zipalign -c -P 16 -v 4 |
Dentro del .so |
Fin de PT_GNU_RELRO (p_vaddr + p_memsz) múltiplo de 0x4000 |
llvm-readelf -Wl, u objdump -p (líneas RELRO) |
La tercera fila la pide la guía para las .so enlazadas con NDK r27 o anterior sin los flags de
abajo, y su versión del 16 de octubre de 2026 precisa que la cuenta solo vale cuando GNU_RELRO
comparte segmento LOAD con datos escribibles detrás: si va en un LOAD propio, la .so cumple
aunque el resto de dividir por 0x4000 no sea cero. El cargador de Android 16 QPR1 en adelante la aplica a su manera,
según el código: si RELRO acaba fuera de 16 KB dentro de un segmento RW más largo, carga la .so
en modo de compatibilidad aunque todos sus p_align valgan 0x4000 (FixMinAlignFor16KiB, en
linker_phdr_16kib_compat.cpp). En android-17.0.0_r1 la misma función baja también a
compatibilidad cuando dos PT_LOAD se solapan al redondear a páginas de 16 KiB —uno acaba más
allá del principio de la página de 16 KiB en la que empieza el siguiente—, aunque todos los
p_align sean 0x4000 (líneas 481-517). La alineación del ZIP, además, solo cuenta para las .so
sin comprimir: con extractNativeLibs="true" no hay nada que alinear.
Sin NDK, el equivalente de llvm-readelf -Wl es objdump -p lib.so | grep -A1 RELRO: la
primera línea da vaddr y la segunda memsz. Sobre libandroidx.graphics.path.so de la copia
de F-Droid de F-Droid Client (fuente 26), el 31 de octubre de 2026:
RELRO off 0x0000000000001c40 vaddr 0x0000000000005c40 paddr 0x0000000000005c40 align 2**0
filesz 0x0000000000000390 memsz 0x00000000000003c0 flags r--
0x5c40 + 0x3c0 = 0x6000, que no es múltiplo de 0x4000; pero RELRO cubre entero el LOAD que
empieza en el mismo vaddr, de memsz 0x390, así que la .so cumple según la guía y el
cargador tampoco la pasa a compatibilidad por eso.
Para ver un caso que sí falla por esta condición, libfb.so de
com.fr.laboussole.track tiene los dos LOAD a p_align 0x10000, pero su RELRO empieza en
0x10d88 y mide 0x278, así que acaba en 0x11000 (no es múltiplo de 0x4000) dentro de un
LOAD que sigue hasta 0x12018. Con ese RELRO, el cargador de android-17.0.0_r1 carga la
.so en modo de compatibilidad.
LOAD off 0x0000000000000d88 vaddr 0x0000000000010d88 paddr 0x0000000000010d88 align 2**16
filesz 0x0000000000000280 memsz 0x0000000000001290 flags rw-
RELRO off 0x0000000000000d88 vaddr 0x0000000000010d88 paddr 0x0000000000010d88 align 2**0
filesz 0x0000000000000278 memsz 0x0000000000000278 flags r--
nativo_1.py --elf16k libfb.so lo resume: «PT_GNU_RELRO 0x10d88 + 0x278 = 0x11000 (mód 0x4000 =
0x1000); relro_fuera_16k True; modo_compat_16k relro». Se ejecuta con
MUESTRARIO_RAIZ=<raíz> python3 -I scripts/muestrario/cifras/nativo_1.py --elf16k <lib.so>….
Con NDK r27 o anterior hay que pedirlo al enlazador:
-Wl,-z,max-page-size=16384
-Wl,-z,common-page-size=16384
«NDK version r28 and higher compile 16 KB-aligned by default.»
El muestrario lo confirma. De las 6.081 .so de 64 bits con nota de NDK r28 o posterior, ninguna
de arm64-v8a ni de x86_64 tiene un PT_LOAD por debajo de 16 KiB. Las únicas tres que sí lo tienen son de riscv64, una ABI que el NDK no soporta
oficialmente («sección 2 · lib/<abi>/ y las ABIs vigentes»): libadbroot.so, libkernelsu.so y libksud.so de KernelSU
(me.weishu.kernelsu), compiladas con r29 y p_align de 4 KiB; las de arm64-v8a de la misma
app, a 0x4000. Con versiones anteriores sí hace falta pedirlo al enlazador: con r27, 348 de
10.198 .so (3 %) siguen a 4 KiB, y con r23, 1.698 de 3.001 (57 %). Por ejemplo,
libunrooted_android.so y libusb1.0.so de RF Analyzer (com.mantz_it.rfanalyzer), NDK r27 sin
los flags, tienen p_align 0x1000 en arm64-v8a. La versión del NDK sale de la nota
.note.android.ident, que pone el enlazador, y no es la del resto del proyecto. Son recuentos de
ficheros.
6.2 Fecha y alcance en Google Play
«To ensure your app works correctly on the latest versions of Android, all apps targeting Android 15 (API level 35) and higher must support 16 KB memory page sizes on 64-bit devices on Google Play. Starting February 1, 2027, if your app updates don't support 16 KB memory page sizes, you won't be able to release these updates.»
Es decir: targetSdk 35 o superior y dispositivos de 64 bits, y la fecha que da hoy la guía, el
1 de febrero de 2027, es la de las actualizaciones. No es el primer plazo: el blog de
Android Developers anunció el 8 de mayo de 2025 que «Starting November 1st, 2025, all new apps and
updates to existing apps submitted to Google Play and targeting Android 15+ devices must support
16 KB page sizes».
La página que fija los requisitos es la ayuda de Play Console, Play Console technical quality requirements. Lo pone entre los requisitos vigentes, los que se aplican ya, y para los app bundles nuevos que se suben: «Apps that contain native code must support devices with 16 KB memory page sizes. Java/Kotlin only apps are compatible by default»; y añade fechas propias para dos factores de forma, el de 64 bits y 16 KB en Wear OS («Required as of 15 Sep, 2026») y en TV («Required as of 1 Aug, 2026»). Leídas juntas, las tres páginas dan esta línea temporal:
| Fecha | Qué | Dónde |
|---|---|---|
| 1 de noviembre de 2025 | Las aplicaciones nuevas y las actualizaciones que apunten a Android 15 o superior tienen que admitir 16 KB | Blog de Android Developers, 8 de mayo de 2025 |
| 1 de agosto de 2026 | Apps de TV: 64 bits y 16 KB obligatorios | Ayuda de Play Console |
| 15 de septiembre de 2026 | Apps de Wear OS: 64 bits y 16 KB obligatorios | Ayuda de Play Console |
| 1 de febrero de 2027 | No se pueden publicar actualizaciones que no admitan 16 KB | Guía de 16 KB y el aviso de Play Console que reproduce su figura 1 |
Las dos filas de los extremos no se contradicen: el requisito rige desde el 1 de noviembre de 2025, y el 1 de febrero de 2027 es la fecha desde la que Play deja de aceptar las actualizaciones que no lo cumplan, la que anuncia el aviso de Play Console de la figura 1 de la guía.
Y una salvedad: la guía solo habla de app updates, y la ayuda, de los app bundles que se suben. Leídas al pie de la letra, ninguna alcanza a una versión ya publicada mientras no se actualice; lo que se bloquea es publicar lo que no cumpla (recuadro de la «sección 1 · Qué es y por qué existe»).
Se nota en los datos que el requisito mira el targetSdk. Entre las apps de Play más instaladas
con código nativo en arm64-v8a y targetSdk 35 o más, el 92 % son compatibles con páginas de
16 KB según la guía («sección 6.3 · Qué se ve en el muestrario»); con targetSdk menor, solo 2 de 38. En F-Droid el salto es
parecido: del 37 % al 94 %. El mercado chino se queda atrás incluso con targetSdk 35 (5 de 16).
Que una app sea compatible no significa que haya cumplido el requisito de Play: aquí solo
medimos el contenido del APK, no la fecha de publicación (el requisito se aplica a actualizaciones
desde el 1 de noviembre de 2025 y la guía da el 1 de febrero de 2027 como fecha límite).
6.3 Qué se ve en el muestrario
Qué parte de las apps cumple la regla de las páginas de 16 KB. Miramos las .so de arm64-v8a
de todas las piezas de cada app, y contamos apps, no ficheros. Hay dos maneras de decir
«compatible», y el texto dice cuál usa cada vez. La de la guía de Android mira dos cosas: que
ningún segmento tenga p_align por debajo de 16 KiB y que el ZIP guarde cada .so sin comprimir
en una posición múltiplo de 16.384. La del cargador de android-17.0.0_r1 suma otras dos: el fin
de RELRO y el solape de PT_LOAD. Se calculan con
MUESTRARIO_RAIZ=<raíz> python3 -I scripts/muestrario/cifras/nativo_1.py --salida (la de la guía)
y python3 -I scripts/muestrario/cifras/alineacion_y_16k_2.py (la del cargador, con el ZIP).
| F-Droid | IzzyOnDroid | Play más instaladas | Play sorteo | Mercado chino | Webs de autores | |
|---|---|---|---|---|---|---|
Apps con alguna .so ELF en lib/arm64-v8a/ |
2.689 | 790 | 546 | 310 | 98 | 5 |
Alguna .so con un PT_LOAD por debajo de 16 KiB |
476 · 18 % | 121 · 15 % | 67 · 12 % | 34 · 11 % | 91 de 98 | 0 de 5 |
Alguna .so sin comprimir fuera de múltiplo de 16.384 en el ZIP |
63 · 2 % | 26 · 3 % | 22 · 4 % | 31 · 10 % | 16 de 98 | 0 de 5 |
Compatible según la guía (p_align y ZIP; las .so que se extraen no cuentan) |
2.201 · 82 % | 662 · 84 % | 471 · 86 % | 263 · 85 % | 7 de 98 | 5 de 5 |
Compatible según el cargador de android-17.0.0_r1 y el ZIP |
2.096 · 78 % | 635 · 80 % | 406 · 74 % | 240 · 77 % | 1 de 98 | 5 de 5 |
Modo de compatibilidad por p_align |
476 · 18 % | 121 · 15 % | 67 · 12 % | 34 · 11 % | 91 de 98 | 0 de 5 |
Modo de compatibilidad por RELRO (con p_align correcto) |
109 · 4 % | 29 · 4 % | 67 · 12 % | 27 · 9 % | 6 de 98 | 0 de 5 |
Modo de compatibilidad por solape de PT_LOAD (con lo anterior correcto) |
0 | 0 | 0 | 1 | 0 de 98 | 0 de 5 |
Cuatro de cada cinco apps cumplen la condición de la guía (entre el 82 % y el 86 % fuera del
mercado chino, donde solo cumplen 7 de 98). El cargador de Android 17 es más exigente: en Play más
instaladas, a las 67 apps que pasan a modo de compatibilidad por p_align se suman otras 67 por
RELRO. En F-Droid el RELRO pesa poco (4 %), y el solape casi no se da (una app en todo el
muestrario). Con el criterio del ZIP
de «alguna .so cargada desde el APK» (solo las que no se extraen), el recuento de F-Droid es 60 de
2.689 en lugar de 63. En los datos hay 3 apps sin veredicto (1 de F-Droid y 2 de Play más
instaladas) que cuentan como no compatibles; sin las dos de Play, Play más instaladas sería
471 de 544 (87 %). Con targetSdk 35 o más el cumplimiento sube («sección 6.2 · Fecha y alcance en Google Play»).
Algunos ejemplos concretos, con el p_align mínimo de los PT_LOAD de sus .so de
arm64-v8a:
| APK | p_align observado |
p_align ≥ 0x4000 |
|---|---|---|
Termux (com.termux, versión 1022) |
0x1000 (4 KB), las tres .so |
❌ |
F-Droid Client (org.fdroid.fdroid, versión 2000052) |
0x4000 |
✅ |
StreetComplete (de.westnordost.streetcomplete, versión 6308) |
0x4000 |
✅ |
SimpleX Chat (chat.simplex.app, versión 385) |
0x4000, y 0x10000 en uno de los cinco PT_LOAD de libsimplex.so |
✅ |
WhatsApp.apk de la web de WhatsApp |
0x4000 en las tres .so |
✅ |
libtermux.so de Termux está compilado con NDK r22b (dato que sale de su propia
.note.android.ident, con API 21 en la nota; libtermux-bootstrap.so de la misma app dice API 24)
y es anterior a todo esto. Pasar de 4 KiB a 16 KiB no exige que sea exactamente 16 KiB: el
requisito es un mínimo. Y las .so a 64 KiB no son raras: una de cada cinco apps de F-Droid con
código nativo en arm64-v8a tiene alguna con todos los segmentos a 64 KiB o más, y en el mercado
chino, casi todas. En F-Droid la causa principal es Flutter: libflutter.so y libapp.so van a
64 KiB (ejemplo: ace.software.pocketsense). En Play más instaladas y en el mercado chino, en
cambio, Flutter explica poco. libsimplex.so de SimpleX Chat mezcla las dos cosas: cuatro
PT_LOAD a 16 KiB y uno a 64 KiB, así que su mínimo es 16 KiB (NDK r23-canary, API 30 en la nota).
Contando ficheros en vez de apps, lo habitual en arm64-v8a es un p_align mínimo de 16.384 (el
64 % en F-Droid y el 88 % en Play más instaladas). El mercado chino se reparte casi a tercios entre
4.096, 16.384 y 65.536.
La última columna de la tabla de ejemplos solo mira p_align, y para el cargador de
android-17.0.0_r1 no basta: también pasan a compatibilidad un RELRO que acaba fuera de 16 KiB
dentro de un segmento escribible más largo y dos PT_LOAD que se solapan al redondear a 16 KiB
(«sección 6.1 · Qué es el requisito»). Comprobadas esas dos condiciones el 31 de octubre de 2026 con
nativo_1.py --elf16k (que aplica la lógica de FixMinAlignFor16KiB a los program headers de
las .so ya extraídas) sobre las nueve .so de arm64-v8a de F-Droid Client, StreetComplete y
SimpleX Chat, ninguna cae en ellas: según esa lógica, cargarían sin compatibilidad. En el conjunto
del muestrario sí hay apps que caen, con las cifras de la tabla de arriba. Un caso de RELRO en Play es el
split_config.arm64_v8a.apk de mod.bussidbusindonesia (targetSdk 36), con 1 de sus 10 .so;
el único caso de solape, dos PT_LOAD que comparten una página de 16 KiB, está en el
split_config.arm64_v8a.apk de com.evilapples.app. Para reproducirlo:
MUESTRARIO_RAIZ=<raíz> python3 -I scripts/muestrario/cifras/nativo_1.py --elf16k <lib.so>…,
que imprime los p_align, el RELRO y el veredicto.
El mercado chino frente a Play. Las tiendas chinas no aplican los requisitos de Google Play, y se
nota. Es un contexto, no una medida: lo que medimos es el contenido de los APK. Solo 7 de las 98
apps chinas con .so en arm64-v8a son compatibles con las páginas de 16 KB según la guía, frente
al 86 % en Play más instaladas, y la distancia se mantiene con targetSdk 35 o más. Según el
cargador de Android 17, solo una de esas 98 se libra del modo de compatibilidad. Con 64 bits no se
puede comparar, porque la cifra de Play sale de cómo se descargaron las apps («sección 2 · lib/<abi>/ y las ABIs vigentes»). Y como
casi ninguna pone extractNativeLibs a false (4 de 100), en el mercado chino casi todas las
.so se instalan comprimidas y se extraen. Ejemplos del mercado chino: cn.cj.pe (tienda 360, protector
Bangcle/SecNeo) y com.tencent.tmgp.cod (Unity).
6.4 Qué pasa en el dispositivo
Ejecutado el 25 de septiembre de 2026 en los emuladores de 16 KB de Android 15 —compilación
AE3A.240806.043, la de salida, equivalente a android-15.0.0_r1— y Android 16
(BE2A.250530.026.F3, android-16.0.0_r1), con una biblioteca de prueba sin libc cuya única
función devuelve 143 si sus segmentos se cargaron bien. La columna de Android 17 sale del código de
android-17.0.0_r1: su imagen de 16 KB no arranca en la máquina de referencia
(«El muestrario → §8 · La máquina de referencia»).
| ELF | ZIP | extractNativeLibs |
Android 15 de salida | Android 16 | Android 17, según el código |
|---|---|---|---|---|---|
| 16 KiB | 16 KiB | false |
Carga desde el APK |
Igual. pageSizeCompat=0 |
Igual |
| 16 KiB | 16 KiB | true |
Carga la copia extraída | Igual | Igual |
| 16 KiB | 4 KiB | false |
No instala: res=-2 |
Instala extrayendo la .so y carga normal. pageSizeCompat=2, aviso «APK alignment check failed» |
Igual, con el aviso nuevo |
| 16 KiB | 4 KiB | true |
Carga | Carga. pageSizeCompat=0 |
Igual |
| 4 KiB | 16 KiB | false |
Instala y falla la carga: empty/missing DT_HASH/DT_GNU_HASH |
Carga en modo de compatibilidad. pageSizeCompat=4, aviso «ELF alignment check failed» |
Igual, con el aviso nuevo |
| 4 KiB | 16 KiB | true |
Igual que la anterior | Igual que la anterior | Igual |
| 4 KiB | 4 KiB | false |
No instala: res=-2 |
Instala extrayendo y carga en compatibilidad. pageSizeCompat=6, aviso «APK and ELF alignment checks failed» |
Igual |
| 4 KiB | 4 KiB | true |
Instala y falla la carga (DT_HASH) |
Compatibilidad. pageSizeCompat=4 |
Igual |
Lo que se ve, literal:
- El rechazo de Android 15:
adb installrespondeFailure [INSTALL_FAILED_INVALID_APK: INSTALL_FAILED_INVALID_APK: Failed to extract native libraries, res=-2]—con el código repetido—, y enlogcatquedaE/NativeLibraryHelper: Library 'libp16k.so' is not PAGE(16384)-aligned - will not be able to open it directly from apk. - El fallo de carga de Android 15:
dlopen failed: empty/missing DT_HASH/DT_GNU_HASH in "…/base.apk!/lib/arm64-v8a/libp16k.so" (new hash type from the future?). No habla de alineación: el cargador de salida mapea los segmentos a 16 KB sin comprobarp_align, lee la tabla dinámica de un sitio donde solo hay ceros y se queja de otra cosa. - La extracción de Android 16:
I/NativeLibraryHelper: 16kB AppCompat: Library 'libp16k.so' is not PAGE(16384)-aligned - falling back to extraction from apk. - Las marcas:
adb shell dumpsys package <paquete>escribepageSizeCompat=N. El 2 es la.sodesalineada en el ZIP; el 4, unPT_LOADconp_alignde 4 KB; el 6, los dos; el 32 y el 64, el atributo del manifiesto. En Android 15 esa línea no existe. - El modo de compatibilidad: en
/proc/<pid>/mapsel código de la.soaparece como memoria anónima,r-xp 00000000 00:00 0sin nombre de fichero; sin él, mapeado desdebase.apko desdelib/arm64/libp16k.so. Cuando funciona, no deja ninguna línea enlogcat. Es lo que se ve con la biblioteca de prueba, en la que el cargador pudo separar código y datos; cuando no puede, el deandroid-17.0.0_r1la carga entera enrwxy avisa enlogcatconfalling back to RWX compat(linker_phdr_16kib_compat.cpp, línea 395; «sección 3.6 · Secciones, símbolos y tabla dinámica»). - El aviso de Android 16: la etiqueta de la aplicación como título, «This app isn’t 16 KB compatible. ELF alignment check failed. This app will be run using page size compatible mode…» y un botón «OK».
Y las variantes que separan la teoría de la práctica:
| Variante | Android 15 de salida | Android 16 |
|---|---|---|
pageSizeCompat="enabled", ELF de 4 KiB |
Falla la carga (DT_HASH) |
Compatibilidad, pageSizeCompat=32 y sin aviso |
pageSizeCompat="disabled", ELF de 4 KiB |
Falla la carga (DT_HASH) |
Falla la carga: "…/libp16k.so" program alignment (4096) cannot be smaller than system page size (16384). pageSizeCompat=64 |
pageSizeCompat="disabled", ZIP de 4 KiB |
No instala | No instala: pageSizeCompat=disabled library 'libp16k.so' is not PAGE(16384)-aligned within apk (APK alignment, not ELF alignment) -and will not be extracted. |
ELF con p_align de 8 KiB |
Carga, y muere en la primera llamada: Fatal signal 4 (SIGILL) |
Falla la carga: program alignment (8192) cannot be smaller…. La compatibilidad de Android 16 solo cubre los 4 KiB exactos |
| Actualización de un ELF de 4 KiB a uno de 16 KiB | La primera falla, la segunda carga | La segunda carga normal, pero conserva pageSizeCompat=4 y vuelve a mostrar el aviso |
El atributo android:pageSizeCompat casi no se usa: lo declaran 19 apps del muestrario (sin
contar los protectores) en la pieza base o única, repartidas entre todos los grupos. En 18 de las 19 el valor numérico
que imprime aapt2 es 32 y en una es 64. La matriz de arriba da la marca pageSizeCompat=32 para
"enabled" y la 64 para "disabled"; esa correspondencia entre el valor del atributo en el
manifiesto compilado y su nombre no la hemos comprobado aparte. Cuatro de las 19 lo declaran sin
llevar ninguna .so ELF de arm64-v8a: no hay biblioteca a la que afecte. Ejemplos: valor 32 en
com.celzero.bravedns (F-Droid); valor 32 sin ninguna .so en lib/ en com.rosan.dhizuku
(F-Droid); y el único con valor 64, en la pieza base.apk del .apkm de com.mi.globalbrowser
14.65.0.
Tres lecturas:
- El instalador nunca rechaza por la alineación ELF; solo por la del ZIP, y Android 16 ni eso: extrae.
- El Android 15 de salida es el peor caso: instala lo que luego no puede cargar, y el error no
dice por qué. Si una aplicación con código nativo falla en un dispositivo de 16 KB con
DT_HASHo conSIGILL, lo primero es mirarp_align. - El modo de compatibilidad no es gratis ni silencioso para el usuario, pero sí para
logcatmientras el cargador pueda separar código y datos («sección 3.6 · Secciones, símbolos y tabla dinámica»). Lo que cambia en Android 17, según el código: el aviso pasa a titularse «Android App Compatibility» y lista las.soafectadas, el atributo del manifiesto ya no lo oculta, las marcas se recalculan al actualizar, cubre cualquierp_alignmenor de 16 KiB y la propiedadbionic.linker.16kb.app_compat.enabledadmite el valorfatal.
6.5 Qué rechaza el cargador
Lo que hace fallar System.loadLibrary o dlopen en el cargador de bionic de
android-17.0.0_r1 por la estructura del ELF de las secciones «3» y «6» —sin los errores de lectura
y de mapeo—, en el orden en que lo comprueba. Las filas con un nivel de API solo son error
si el targetSdkVersion de la aplicación llega a él; por debajo, el cargador deja un aviso en
logcat y sigue (DL_ERROR_AFTER, linker_globals.cpp, líneas 55-75).
| Qué | Mensaje | Dónde | Error desde targetSdk |
|---|---|---|---|
Magia, clase, EI_DATA, e_type, e_version o e_machine que no son los del proceso |
has bad ELF magic, is 32-bit instead of 64-bit, not little-endian, has unexpected e_type, is for … instead of … |
linker_phdr.cpp, 273-324 |
Siempre |
e_shentsize distinto del tamaño de Elf64_Shdr, o e_shstrndx = 0 |
has unsupported e_shentsize, has invalid e_shstrndx |
linker_phdr.cpp, 326-339 |
26 |
| Sin tabla de secciones, o con ella fuera del fichero («sección 3.6 · Secciones, símbolos y tabla dinámica») | has no section headers, has invalid shdr offset/size |
linker_phdr.cpp, 391-405 |
Siempre |
Sin sección SHT_DYNAMIC |
.dynamic section header was not found |
linker_phdr.cpp, 427-430 |
Siempre |
.dynamic con offset o tamaño distintos de los de PT_DYNAMIC |
.dynamic section has invalid offset, … invalid size |
linker_phdr.cpp, 443-462 |
26 |
sh_link de .dynamic fuera de la tabla, o que no lleva a una SHT_STRTAB |
.dynamic section has invalid sh_link, … invalid link(…) sh_type |
linker_phdr.cpp, 465-478 |
Siempre |
Ningún PT_LOAD |
has no loadable segments |
linker_phdr.cpp, 670-673 |
Siempre |
En un dispositivo de 16 KiB sin modo de compatibilidad, un PT_LOAD alineado por debajo de la página, con las dos condiciones que añade FixMinAlignFor16KiB («sección 6.1 · Qué es el requisito») |
program alignment (…) cannot be smaller than system page size (…) |
linker_phdr.cpp, 996-1008 |
Siempre |
Un PT_LOAD con contenido en el fichero que es a la vez escribible y ejecutable |
has load segments that are both writable and executable |
linker_phdr.cpp, 1054-1062 |
26 |
Sin PT_DYNAMIC |
missing PT_DYNAMIC |
linker.cpp, 2894-2898 |
Siempre |
| Un segmento TLS cuya alineación no es potencia de 2 | TLS segment alignment in "…" is not a power of 2 |
linker.cpp, 2915-2919 |
Siempre |
DT_GNU_HASH con un maskwords que no es potencia de 2, o DT_SYMENT distinto de 24 en ELF64 |
invalid maskwords for gnu_hash, invalid DT_SYMENT |
linker.cpp, 2957-2961 y 2979-2985 |
Siempre |
DT_TEXTREL, o DF_TEXTREL en DT_FLAGS, en una biblioteca de 64 bits |
has text relocations |
linker.cpp, 3181-3188 y 3198-3205 |
Siempre |
Ni DT_HASH ni DT_GNU_HASH |
empty/missing DT_HASH/DT_GNU_HASH in "…" (new hash type from the future?) |
linker.cpp, 3322-3326 |
Siempre |
Sin DT_STRTAB o sin DT_SYMTAB |
empty/missing DT_STRTAB, empty/missing DT_SYMTAB |
linker.cpp, 3327-3334 |
Siempre |
DT_TEXTREL, o DF_TEXTREL, en una biblioteca de 32 bits |
has text relocations |
linker.cpp, 3407-3411 |
23 |
Las relocalizaciones de texto que quedan en el muestrario son de 32 bits y de apps modernas. Hay
6 .so con DT_TEXTREL o DF_TEXTREL: 4 en apps de Google Play más instaladas y 2 del mercado
chino. Todas son de 32 bits y están en apps con targetSdk de 33 a 36, que es más de 23: el
cargador las rechazaría con has text relocations si llegaran a cargarse. Que se carguen no lo
hemos comprobado. En 64 bits no hay ninguna. Tres están en x86 o armeabi y 2 en apps que la
heurística de nombres marca como empaquetadas. Casos:
lib/armeabi/liblbs.soencom.chinalife.ebz(tienda 360,targetSdk34).lib/x86/libuptsmaddon.soencom.yek.android.kfc.activitys(tienda 360,targetSdk35).lib/x86/libopenvpnexe_old.soen elsplit_config.x86.apkdel.apkmdecom.instabridge.android26.10.4.4 (targetSdk36).lib/armeabi-v7a/libffmpeg_xm.soen la variante de APKMirror decom.miui.player9.42.01.100920i (targetSdk36).lib/armeabi-v7a/libandengine.soen elsplit_config.armeabi_v7a.apkdel.apkmdecom.superbinogo.jungleboyadventure4.5.83.304 (targetSdk35).lib/armeabi-v7a/liblbs.soen la variante de APKMirror decom.tencent.iglite0.26.0 (targetSdk33).
Los tres PT_LOAD escribibles y ejecutables a la vez son de ejecutables ET_EXEC de F-Droid, no
de bibliotecas que se carguen con dlopen: libproot-loader32.so en com.inspiredandroid.kai
(arm64-v8a y x86_64, targetSdk 37) y libvmlinux.so en sh.haven.app (targetSdk 35). Son
recuentos de ficheros.
Tres casos que parecen de la tabla y no lo son. Un p_align que no es potencia de 2 no se
rechaza: el cargador avisa con has invalid p_align y no lo tiene en cuenta al calcular la
alineación (linker_phdr.cpp, líneas 567-575). El RX|RW compat loading failed del modo de
compatibilidad tampoco: la biblioteca se carga igual, entera en rwx («sección 3.6 · Secciones, símbolos y tabla dinámica»). Y el
empty/missing DT_HASH/DT_GNU_HASH del Android 15 de salida con un ELF de 4 KiB en un dispositivo
de 16 KiB («sección 6.4 · Qué pasa en el dispositivo») no es una tabla hash que falte: es la tabla dinámica leída de un sitio
donde solo hay ceros.
7. Stripping de símbolos
«By default, native code libraries are stripped in release builds of your app. This stripping consists of removing the symbol table and debugging information contained in any native libraries used by your app.»
7.1 Qué se pierde y qué queda
| Se pierde | Sobrevive |
|---|---|
.symtab: nombres de todas las funciones, incluidas las internas |
.dynsym: solo los símbolos exportados e importados |
.debug_*: ficheros fuente, números de línea, tipos |
.dynstr, .dynamic, NEEDED, SONAME |
| Nombres de variables locales | .rodata: los strings literales siguen ahí |
En un .so sin stripping el desensamblador etiqueta cada función con su nombre real; con
stripping, todo lo no exportado aparece como sub_1A40 o FUN_00101a40 y reconstruirlo es
trabajo manual. Es lo que se ve en el muestrario: libtermux.so de Termux y
libandroidx.graphics.path.so de F-Droid Client responden no symbols a nm, que solo lee
.symtab, y conservan .dynsym intacta.
Casi todas pasan por ahí: solo el 6 % de las .so de F-Droid y el 3 % de las de Google Play más
instaladas conservan .symtab. Pero contando apps salen más, porque basta una biblioteca de
terceros: llevan alguna .so con .symtab entre el 12 % y el 23 % de las apps con código nativo,
y 43 de 100 en el mercado chino.
Un ejemplo es libdatastore_shared_counter.so, de Jetpack DataStore (NDK r20), en
com.ekinao.desktopmascot (F-Droid): nm lista 32 símbolos, entre ellos los
Java_androidx_datastore_core_NativeSharedCounter_* y nombres locales de C++. No confirmamos que
haya más .symtab en F-Droid e IzzyOnDroid, que se compilan desde el código fuente, que en Play.
Por ficheros sí: 6 % en F-Droid y 9 % en IzzyOnDroid frente a 3 % en Play más instaladas y 4 % en el
sorteo. Por apps no: 16 % y 17 % frente a 23 %.
Una .so puede llevar pistas para encontrar sus símbolos fuera del fichero. La más útil es el
build-id, con el que se casa un fallo con sus símbolos, y está en la gran mayoría (el 80 % de las
de F-Droid y el 89 % de las de Play más instaladas). El enlace .gnu_debuglink es raro (entre el
3 % y el 7 % en Play), y la información de depuración (.debug_*) no llega al 1 %.
Lo peor para el analista es una .so sin .symtab que solo exporta JNI_OnLoad, porque se suma a
RegisterNatives («sección 4.4 · Por qué RegisterNatives complica el análisis estático»). Entre las .so propias (nombre en menos de 3 apps), es lo que
encuentras en una de cada cinco en Google Play más instaladas y en el 27 % del mercado chino,
frente al 4 % en F-Droid. «Propia» es una aproximación por el nombre del fichero.
7.2 Los símbolos de depuración de Play Console
El desarrollador conserva los símbolos y los sube por separado, para que Play pueda simbolicar los informes de fallo. Se configura en Gradle:
android.buildTypes.release.ndk.debugSymbolLevel = { SYMBOL_TABLE | FULL }
| Valor | Contenido |
|---|---|
NONE |
Por defecto. Sin símbolos |
SYMBOL_TABLE |
Nombres de función. Fichero más pequeño |
FULL |
Nombres de función, ficheros y números de línea |
El artefacto sale en
app/build/outputs/native-debug-symbols/<variant-name>/native-debug-symbols.zip, con un
límite de 1,6 GB.
Para el análisis, esto significa que los símbolos existen pero no están en el APK. No hay
vía legítima de recuperarlos desde el binario distribuido: es el equivalente nativo del
mapping.txt de «R8 y ProGuard», con la diferencia de
que Play nunca lo publica. El build-id de la «sección 7.1 · Qué se pierde y qué queda» es el dato con el que se casa un fallo
con sus símbolos. No hemos comprobado en el muestrario cómo lo usa Play.
8. Recetas
Todo lo de abajo usa /usr/bin/objdump —Apple LLVM 21.0.0, que sabe leer ELF pese a ser el
de macOS—, /usr/bin/nm y xxd; con las herramientas del NDK no lo hemos comprobado (recuadro de la
«sección 1 · Qué es y por qué existe»).
8.1 Inventariar las ABIs presentes
Los APK de los ejemplos son del «muestrario». Esta receta usa
Tuta (de.tutao.tutanota_396715.apk), descargado de
https://f-droid.org/repo/de.tutao.tutanota_396715.apk el 19 de octubre de 2026. La salida la
obtuvimos el 31 de octubre de 2026.
MUESTRAS=<carpeta donde está el APK>
unzip -l $MUESTRAS/de.tutao.tutanota_396715.apk \
| awk '$4 ~ /^lib\// {split($4,a,"/"); c[a[2]]++; s[a[2]]+=$1}
END {for (k in c) printf "%-14s %3d entradas %10d bytes\n", k, c[k], s[k]}' | sort
arm64-v8a 6 entradas 16218568 bytes
armeabi 1 entradas 126980 bytes
armeabi-v7a 6 entradas 11183636 bytes
mips 1 entradas 130556 bytes
mips64 1 entradas 150256 bytes
x86 4 entradas 6378716 bytes
x86_64 6 entradas 18552536 bytes
Esta receta mira solo el APK que se le da. En Google Play, las .so suelen estar en los splits de
ABI (split_config.arm64_v8a.apk) y no en la base: hay que repetirla sobre cada pieza («sección
2.4 · Dónde van las .so en las apps de Google Play»). Sin agregación, unzip -l … | grep '^lib/' | cut -d/ -f2 | sort -u basta para la lista de
directorios.
8.2 Extraer una .so y leer su cabecera con xxd
Se usa libtermux.so de Termux (com.termux_1022.apk), salida del 31 de octubre de 2026.
unzip -o -q $MUESTRAS/com.termux_1022.apk "lib/arm64-v8a/libtermux.so" -d /tmp/so/
xxd -l 64 /tmp/so/lib/arm64-v8a/libtermux.so
00000000: 7f45 4c46 0201 0100 0000 0000 0000 0000 .ELF............
00000010: 0300 b700 0100 0000 e40f 0000 0000 0000 ................
00000020: 4000 0000 0000 0000 981e 0000 0000 0000 @...............
00000030: 0000 0000 4000 3800 0800 4000 1700 1600 ....@.8...@.....
Contra las tablas 3.1 y 3.2: magic \x7fELF; EI_CLASS = 02 = ELFCLASS64; EI_DATA =
01 = ELFDATA2LSB; e_type = 0x0003 = ET_DYN; e_machine = 0x00B7 = 183 =
EM_AARCH64; e_entry = 0xFE4; e_phoff = 0x40; e_shoff = 0x1E98, distinto de cero, así
que la tabla de secciones sigue ahí; y e_ehsize = 64, e_phentsize = 56, e_phnum = 8,
e_shentsize = 64, e_shnum = 23, e_shstrndx = 22.
La misma biblioteca en lib/armeabi-v7a/ empieza por
7f45 4c46 0101 0100 … 0300 2800 0100 0000 300b 0000 3400 0000: EI_CLASS = 01 =
ELFCLASS32, e_machine = 0x0028 = 40 = EM_ARM, e_entry = 0xB30 y e_phoff = 0x34 en
vez de 0x40 porque la cabecera de 32 bits mide 52 bytes.
8.3 Comprobar la alineación de 16 KB con objdump -p
Se usan libtermux.so de Termux y libandroidx.graphics.path.so de F-Droid Client
(org.fdroid.fdroid_2000052.apk), salida del 31 de octubre de 2026.
objdump -p /tmp/so/lib/arm64-v8a/libtermux.so | grep "LOAD"
unzip -o -q $MUESTRAS/org.fdroid.fdroid_2000052.apk \
"lib/arm64-v8a/libandroidx.graphics.path.so" -d /tmp/fd/
objdump -p /tmp/fd/lib/arm64-v8a/libandroidx.graphics.path.so | grep "LOAD"
LOAD off 0x0000000000000000 vaddr 0x0000000000000000 paddr 0x0000000000000000 align 2**12
LOAD off 0x00000000000019c0 vaddr 0x00000000000029c0 paddr 0x00000000000029c0 align 2**12
LOAD off 0x0000000000000000 vaddr 0x0000000000000000 paddr 0x0000000000000000 align 2**14
LOAD off 0x0000000000001c40 vaddr 0x0000000000005c40 paddr 0x0000000000005c40 align 2**14
LOAD off 0x0000000000001fd0 vaddr 0x0000000000009fd0 paddr 0x0000000000009fd0 align 2**14
2**12 = 4.096: libtermux.so no cumple. 2**14 = 16.384: el .so de 2026 sí. Como
alternativa, MUESTRARIO_RAIZ=<raíz> python3 -I scripts/muestrario/cifras/nativo_1.py --elf16k <lib.so>…
da además el RELRO y el veredicto del cargador («sección 6.3 · Qué se ve en el muestrario»).
8.4 Listar los símbolos JNI
Mismas dos .so, salida del 31 de octubre de 2026.
objdump -T /tmp/so/lib/arm64-v8a/libtermux.so | grep -E "Java_|JNI_OnLoad"
objdump -T /tmp/fd/lib/arm64-v8a/libandroidx.graphics.path.so | grep -E "Java_|JNI_OnLoad"
000000000000179c g DF .text 0000000000000008 Java_com_termux_terminal_JNI_close
0000000000001020 g DF .text 00000000000006a0 Java_com_termux_terminal_JNI_createSubprocess
0000000000001700 g DF .text 0000000000000054 Java_com_termux_terminal_JNI_setPtyUTF8Mode
00000000000016c0 g DF .text 0000000000000040 Java_com_termux_terminal_JNI_setPtyWindowSize
0000000000001754 g DF .text 0000000000000048 Java_com_termux_terminal_JNI_waitFor
00000000000016c8 g DF .text 00000000000001c0 LIBANDROIDX.GRAPHICS.PATH JNI_OnLoad
Las cinco primeras líneas son la vía A; la última, un binario entero cuya única exportación
propia es JNI_OnLoad: vía B.
8.5 Confirmar el stripping y leer la huella del NDK
Misma libtermux.so, salida del 31 de octubre de 2026.
nm /tmp/so/lib/arm64-v8a/libtermux.so
objdump -s -j .note.android.ident /tmp/so/lib/arm64-v8a/libtermux.so | sed -n '3,5p'
/tmp/so/lib/arm64-v8a/libtermux.so: no symbols
Contents of section .note.android.ident:
0200 08000000 84000000 01000000 416e6472 ............Andr
0210 6f696400 15000000 72323262 00000000 oid.....r22b....
nm lee .symtab; «no symbols» confirma el stripping, mientras objdump -T, que lee
.dynsym, sí devuelve símbolos. La nota dice Android, 0x15 = 21 —el nivel de API con el
que se compiló— y r22b, la versión del NDK: una huella útil para fechar una biblioteca. El nivel
de API puede cambiar entre las .so de una misma app: libtermux.so y liblocal-socket.so dicen
21 y libtermux-bootstrap.so, 24. No hemos comprobado que sea el minSdk de la app.
No todas las .so tienen la nota. Falta en pocas de F-Droid y de Play más instaladas (6-7 %) y en
una de cada cuatro del mercado chino. Son bibliotecas que no salen del NDK, como libapp.so de
Flutter en ace.software.pocketsense. Y la versión que dice es la del enlazado, no la del resto del
proyecto. En F-Droid lo más repetido es el NDK r25c, y en Play más instaladas, el r27c; en el
mercado chino aún hay muchas del r16b y el r21b. Son recuentos de ficheros.
Fuentes
- Android ABIs — NDK — https://developer.android.com/ndk/guides/abis
Consultado el 12 de agosto de 2026. De aquí sale la tabla de ABIs vigentes de la «sección
2.1 · Las cuatro vigentes», sus notas literales, y la frase sobre la eliminación de
armeabi,mipsymips64en NDK r17 de la «sección 2.2 · Las eliminadas». - System V ABI (gABI) — ELF Header — https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html
Consultado el 12 de agosto de 2026. De aquí salen la estructura
Elf64_Ehdrde la «sección 3.1 · Cabecera ELF64», los índices dee_identde la 3.2 y los valoresELFCLASS64,ELFDATA2LSB,ET_DYN,EM_386,EM_ARMyEM_X86_64. Consultado de nuevo el 18 de octubre de 2026: de aquí sale quee_shoffvale 0 en un fichero sin tabla de secciones (secciones «3.1» y «3.6»). - System V ABI (gABI) — Program Header — https://refspecs.linuxfoundation.org/elf/gabi4+/ch5.pheader.html
Consultado el 12 de agosto de 2026. De aquí salen la estructura
Elf64_Phdrde la «sección 3.4 · program header», la definición dep_aligny los valoresPT_LOAD,PT_DYNAMIC,PT_NOTEyPT_PHDR. - ELF for the Arm 64-bit Architecture (AAELF64) — https://github.com/ARM-software/abi-aa/blob/main/aaelf64/aaelf64.rst
Consultado el 12 de agosto de 2026. De aquí sale
EM_AARCH64 (183, 0xB7)de la «sección 3.3 · e_machine por ABI», que la especificación gABI no lista. - JNI Tips — Android Developers — https://developer.android.com/training/articles/perf-jni
Consultado el 12 de agosto de 2026. De aquí salen las citas sobre
System.loadLibrary, el ejemplo deJNI_OnLoadconRegisterNatives, la recomendación de Google y la recomendación de-fvisibility=hiddende las secciones «4.1», «4.3» y «4.4». - Java Native Interface Specification — Design Overview — https://docs.oracle.com/javase/8/docs/technotes/guides/jni/spec/design.html
Consultado el 12 de agosto de 2026. De aquí salen la regla de composición del nombre
mangled, la tabla de escapes
_0–_3y la regla del nombre corto frente al largo de la «sección 4.2 · Vía A: descubrimiento por nombre (dlsym)». - Support 16 KB page sizes — Android Developers — https://developer.android.com/guide/practices/page-sizes
Consultado el 12 de agosto, el 25 de septiembre y el 18 de octubre de 2026. De aquí salen la
comprobación de
2**14sobre los segmentosLOADy la del fin de RELRO de la «sección 6.1 · Qué es el requisito», los flags de enlazado, la afirmación de que NDK r28 alinea por defecto y la fecha y el alcance del requisito de Google Play de la «sección 6.2 · Fecha y alcance en Google Play». En la consulta del 18 de octubre la página, que se había actualizado el 16 de octubre de 2026, mantiene la fecha y el texto del requisito de Play —que solo habla de «app updates» y no dice qué pasa con las versiones ya publicadas que no se actualicen («sección 6.2 · Fecha y alcance en Google Play»)—; documenta para Android 17 el valorfataldebionic.linker.16kb.app_compat.enabled, que la «sección 6.4 · Qué pasa en el dispositivo» ya daba por el código, y precisa que la cuenta de RELRO solo vale cuandoGNU_RELROcomparteLOADcon datos escribibles («sección 6.1 · Qué es el requisito»). No dice que Android 17 desactive el modo de compatibilidad por defecto, y sigue diciendo que fijarandroid:pageSizeCompatquita el aviso. Su figura 1 reproduce el aviso de Play Console —texto alternativo «Google Play Console warning that app updates must support 16 KB memory page sizes by February 1, 2027»—, que es la última fila de la tabla de la «sección 6.2 · Fecha y alcance en Google Play». <application>— android:extractNativeLibs — https://developer.android.com/guide/topics/manifest/application-element Consultado el 12 de agosto de 2026. De aquí sale la descripción del atributo de la «sección 5 · extractNativeLibs y lo que implica para el ZIP» y la advertencia sobre su valor por defecto.- Android Gradle Plugin 3.6.0 release notes — https://developer.android.com/build/releases/past-releases/agp-3-6-0-release-notes
Consultado el 12 de agosto de 2026. De aquí sale que AGP fija
extractNativeLibsa"false"por defecto («sección 5 · extractNativeLibs y lo que implica para el ZIP»). - Include native symbols in your release build — https://developer.android.com/build/include-native-symbols
Consultado el 12 de agosto de 2026. De aquí salen la cita sobre el stripping por defecto,
los valores
NONE,SYMBOL_TABLEyFULL, la ruta del artefacto y el límite de 1,6 GB de la «sección 7 · Stripping de símbolos». Consultado de nuevo el 18 de octubre de 2026 (actualizada el 21 de septiembre): el límite de 1,6 GB sigue en la página. - Android 16 — cambios de comportamiento para todas las aplicaciones —
https://developer.android.com/about/versions/16/behavior-changes-all
Consultado el 25 de septiembre de 2026; la página se actualizó el 16 de septiembre. De aquí
salen el modo de compatibilidad de 16 KB y el atributo
android:pageSizeCompat(«sección 6.1 · Qué es el requisito»). - Prepare your apps for Google Play's 16 KB page size compatibility requirement — Android Developers Blog — https://android-developers.googleblog.com/2025/05/prepare-play-apps-for-devices-with-16kb-page-size.html Consultado el 25 de septiembre de 2026. De aquí sale el plazo del 1 de noviembre de 2025 para las aplicaciones nuevas y las actualizaciones («sección 6.2 · Fecha y alcance en Google Play»).
libc/kernel/uapi/linux/elf.hde bionic (etiquetaandroid-16.0.0_r1) — https://android.googlesource.com/platform/bionic/+/refs/tags/android-16.0.0_r1/libc/kernel/uapi/linux/elf.h Consultado el 25 de septiembre de 2026. De aquí sale la estructuraElf32_Phdrde la «sección 3.4 · program header».- AOSP — el cargador de bionic en las etiquetas
android-15.0.0_r1,android-15.0.0_r6,android-16.0.0_r1yandroid-17.0.0_r1— https://android.googlesource.com/platform/bionic/+/refs/tags/android-16.0.0_r1/linker/linker_phdr.cpp y, en el mismo directorio,linker_phdr_16kib_compat.cppylinker.cpp. Consultado el 25 de septiembre de 2026. De aquí salen la falta de comprobación dep_alignen el Android 15 de salida, el error de QPR1, el modo de compatibilidad y lo que cambia en Android 17 (secciones «6.1» y «6.4»). Consultado de nuevo el 18 de octubre de 2026 enandroid-16.0.0_r1: de aquí sale por qué el modo de compatibilidad deja ejecutables los datos de solo lectura (IsEligibleFor16KiBAppCompatySetup16KiBAppCompat, líneas 125-220 delinker_phdr_16kib_compat.cpp;phdr_table_protect_gnu_relro_16kib_compat, líneas 1415-1428 delinker_phdr.cpp, quelinker.cppllama en la línea 3447), en la «sección 6.1 · Qué es el requisito». - AOSP —
core/jni/com_android_internal_content_NativeLibraryHelper.cppyservices/core/java/com/android/server/pm/ScanPackageUtils.javaen las etiquetasandroid-15.0.0_r1,android-16.0.0_r1yandroid-17.0.0_r1— https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-16.0.0_r1/core/jni/com_android_internal_content_NativeLibraryHelper.cpp Consultado el 25 de septiembre de 2026. De aquí salen el rechazo por offset, la extracción de rescate y las marcaspageSizeCompat(secciones «5» y «6.4»). - Emuladores de 16 KB de Android 15 y 16 — imágenes
google_apis_ps16karm64-v8a, compilacionesAE3A.240806.043yBE2A.250530.026.F3, con el emulador 37.1.11. Ejecutado el 25 de septiembre de 2026. De aquí sale la matriz de la «sección 6.4 · Qué pasa en el dispositivo». - Android 15 Compatibility Definition (CDD), apartado 3.3.1 —
https://source.android.com/docs/compatibility/15/android-15-cdd
Consultado el 25 de septiembre de 2026, con los de Android 14, 16 y 17. De aquí sale la
lista cerrada de ABIs con
riscv64y en qué versión entra («sección 2 · lib/<abi>/ y las ABIs vigentes»). - Android NDK — Changelog r27 — https://github.com/android/ndk/wiki/Changelog-r27
Consultado el 25 de septiembre de 2026, con los de r28 a r30. De aquí sale que el sysroot de
riscv64no está soportado para aplicaciones («sección 2 · lib/<abi>/ y las ABIs vigentes»). - AOSP — elección de la ABI primaria (etiqueta
android-17.0.0_r1) — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/jni/com_android_internal_content_NativeLibraryHelper.cpp (findSupportedAbi, líneas 488-542) y, en la misma etiqueta,core/java/com/android/internal/content/NativeLibraryHelper.java(líneas 234-255),services/core/java/com/android/server/pm/PackageAbiHelperImpl.java(líneas 385-466 paramultiArch, 316-345 para sus listas de ABIs nativas y 468-520 para el caso normal) yservices/core/java/com/android/server/am/ProcessList.java(líneas 2033-2046). Consultado el 18 de octubre de 2026. De aquí salen la regla de la primera ABI deBuild.SUPPORTED_ABIScon directorio, que no se mezclan directorios, que el proceso arranca con esa ABI y elINSTALL_FAILED_NO_MATCHING_ABIS(-113) cuando haylib/sin ninguna coincidencia, y la excepción deandroid:multiArch, con sus listas de ABIs nativas desdetargetSdk35 («sección 2 · lib/<abi>/ y las ABIs vigentes»). - Get your apps ready for the 64-bit requirement — Android Developers Blog — https://android-developers.googleblog.com/2019/01/get-your-apps-ready-for-64-bit.html Publicado el 15 de enero de 2019. Consultado el 18 de octubre de 2026. De aquí salen las fechas del 1 de agosto de 2019 y del 1 de agosto de 2021 del requisito de 64 bits de Google Play («sección 2 · lib/<abi>/ y las ABIs vigentes»). La página vigente del requisito, https://developer.android.com/google/play/requirements/64-bit, actualizada el 16 de octubre de 2026, ya no da fechas.
objdump -p, Apple LLVM 21.0.0 — ejecutado el 31 de octubre de 2026 sobre las.sode los APK de la fuente 26, para las salidas de las secciones «3.5», «6.1» y «8».- System V ABI (gABI) — Sections, Symbol Table y Dynamic Section —
https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.sheader.html,
https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.symtab.html y
https://refspecs.linuxfoundation.org/elf/gabi4+/ch5.dynamic.html
Consultado el 18 de octubre de 2026. De aquí salen
Elf64_ShdryElf32_Shdr, los valoresSHT_*y el sentido desh_linkysh_info;Elf64_SymyElf32_Sym,STB_*,STT_*,STV_*,SHN_UNDEFy quest_valuees una dirección virtual en un.so; yElf64_DynyElf32_Dyn, los valoresDT_*de 0 a 30,DF_TEXTREL = 0x4, qued_ptres una dirección virtual y quenchaines igual al número de símbolos («sección 3.6 · Secciones, símbolos y tabla dinámica»). libc/kernel/uapi/linux/elf.hde bionic (etiquetaandroid-17.0.0_r1) — https://android.googlesource.com/platform/bionic/+/refs/tags/android-17.0.0_r1/libc/kernel/uapi/linux/elf.h Consultado el 18 de octubre de 2026, descargado con?format=TEXTy decodificado. De aquí salen, en la «sección 3.6 · Secciones, símbolos y tabla dinámica»,DT_GNU_HASH = 0x6ffffef5(línea 82),Elf32_DynyElf64_Dyn(líneas 114-127),Elf32_SymyElf64_Sym(150-165), losSHT_*(222-233),SHN_UNDEF(255) yElf32_ShdryElf64_Shdr(263-286), los mismos que da el gABI.- AOSP — el cargador de bionic (etiqueta
android-17.0.0_r1) — https://android.googlesource.com/platform/bionic/+/refs/tags/android-17.0.0_r1/linker/linker_phdr.cpp y, en el mismo directorio,linker.cpp,linker_soinfo.cpp,linker_globals.cppylinker_phdr_16kib_compat.cpp. Consultado el 18 de octubre de 2026, descargado con?format=TEXTy decodificado. De aquí salen la disposición deDT_GNU_HASH(linker.cpp, líneas 2938-2965;gnu_lookup, líneas 300-338 delinker_soinfo.cpp), que el cargador lee los símbolos porPT_DYNAMIC(prelink_image, líneas 2881-2985) y que exige la tabla de secciones (linker_phdr.cpp, líneas 391-478), en la «sección 3.6 · Secciones, símbolos y tabla dinámica»; el solape dePT_LOADdeFixMinAlignFor16KiB(linker_phdr_16kib_compat.cpp, líneas 481-517) de la 6.1 y la 6.3; el uso desh_flagsysh_addralignen el modo de compatibilidad (get_max_section_alignment, líneas 92-102 y 219-226;SetupRWXAppCompatySetup16KiBAppCompat, 392-416) de la 3.6; y cada fila de la tabla de la 6.5 con las líneas que da, junto conDL_ERROR_AFTER(linker_globals.cpp, líneas 55-75) y el aviso dep_align(linker_phdr.cpp, líneas 567-575). - Play Console technical quality requirements — Play Console Help — https://support.google.com/googleplay/android-developer/answer/17492799 Consultado el 18 de octubre de 2026. De aquí salen que el soporte de 16 KB es un requisito vigente para las aplicaciones con código nativo y los app bundles que se suben, con la cita de la «sección 6.2 · Fecha y alcance en Google Play», y las fechas de Wear OS (15 de septiembre de 2026) y TV (1 de agosto de 2026).
- Copias de F-Droid de seis
APKdel muestrario — descargados de https://f-droid.org/repo/ el 19 de octubre de 2026 (los mismos que describe «El muestrario»):com.termux_1022.apk,org.fdroid.fdroid_2000052.apk,de.westnordost.streetcomplete_6308.apk,chat.simplex.app_385.apk,de.tutao.tutanota_396715.apkycom.fr.laboussole.track_50020.apk. Sobre ellas se ejecutó el 31 de octubre de 2026objdump(Apple LLVM 21.0.0) para las salidas de las secciones «3.5», «6.1» y «8»;nativo_1.py --recorridopara el ejemplo de la 3.6; ynativo_1.py --elf16kpara las condiciones deFixMinAlignFor16KiBde la 6.3. Las cifras por grupo salen denativo_1.pysobre las 15.183 piezas del muestrario (MUESTRARIO_RAIZ=<raíz> python3 -I scripts/muestrario/cifras/nativo_1.py --salida; las de la «sección 6.3 · Qué se ve en el muestrario» con el cargador, descripts/muestrario/cifras/alineacion_y_16k_2.py).