Alineación y zipalign
Antes conviene leer «Contenedor ZIP» · «APK Signing Block»
1. Qué es y por qué existe
Un APK instalado no se desempaqueta. Android lee de él mientras la app viva, y si una entrada va
sin comprimir (stored) y sus datos empiezan en un offset alineado, puede mapearla con
mmap(2) directamente desde el fichero, sin copiarla a RAM. Eso es lo que prepara zipalign
(lo tienes en el «glosario»): pone todas las entradas stored a
4 bytes («sección 2 · La alineación de 4 bytes») y, con -P 16, las .so a 16 KiB («sección 3 · La regla de las páginas de 16 KiB»). Las comprimidas no se alinean
nunca, porque no se mapean; al comprobar, zipalign las marca (OK - compressed).
La cita de la documentación y el mecanismo del relleno —ceros al final del extra field del
Local File Header, que el Central Directory no refleja— ya están en las secciones «10.3» y «8.1»
de «Contenedor ZIP». Aquí nos quedamos con la parte que
toca a la firma: el registro de alineación de apksigner, el orden respecto a la firma
(«sección 4 · El orden importa: alinear ANTES de firmar») y zipalign -c como verificador («sección 5 · zipalign -c como verificador»).
Que las entradas comprimidas no se alinean se nota en cuanto miras APK reales: sus offsets caen en cada resto módulo 4 más o menos una vez de cada cuatro, que es justo lo que da el azar.
1.1 Dos formas de rellenar
zipalign rellena con ceros. apksigner sign (con build-tools 36.0.0 o posterior y sus
valores por defecto) hace otra cosa: tira el relleno que hubiera, incluido cualquier registro
0xd935 anterior, y escribe el suyo propio en el extra field de cada entrada stored
(ApkSigner.java). Ese registro lleva el header id 0xd935, 2 bytes con el múltiplo de
alineación y los ceros que falten, con un mínimo de 6 bytes. zipalign, en cambio, respeta el
extra field que ya trae la entrada y solo añade ceros detrás si los datos no caen donde deben.
Así que si pasas zipalign sobre un APK que ya alineó apksigner, los registros 0xd935 se
quedan como estaban («sección 4.2 · La demostración»).
En la práctica, lo normal sigue siendo el relleno de ceros: lo llevan entre el 80 % y el 95 % de
los APK según la fuente. El registro 0xd935 es minoritario (alrededor del 1 % en Google Play,
el 9 % en F-Droid), con una excepción llamativa: el mercado chino, donde aparece en 43 de cada
100 piezas. Las dos formas pueden convivir en un mismo APK, lo que encaja con un zipalign
pasado sobre algo ya alineado por apksigner, aunque eso es una hipótesis: no sabemos qué
herramienta alineó cada APK. Y que un APK no lleve relleno no significa que esté mal alineado;
puede que sus datos ya cayeran en su sitio, o que no tenga ninguna entrada stored.
¿Quién escribe el 0xd935? La firma v1 no dice quién alineó, pero da una pista. Lo llevan muchos
APK firmados con SignApk (50 de 53), bastantes de jarsigner y apksigner, y ninguno de
los 765 firmados por el plugin de Gradle. Así que «lo pone el plugin de Android» no es una
explicación válida. El valor guardado es 4 en casi todas las entradas; 16.384 en unas pocas, y
4.096 en una treintena.
Un último matiz: el relleno vive en el Local File Header, y el Central Directory suele no
reflejarlo, pero no siempre. Hay APK con el registro 0xd935 también en el Central Directory.
2. La alineación de 4 bytes
Es la regla general, la que aplica zipalign 4: toda entrada stored debe empezar en un
múltiplo de 4 bytes. La razón es el acceso alineado a palabra. resources.arsc es una
jerarquía de chunks cuyas cabeceras se leen como uint32, y leerlas desde una dirección
desalineada es, en el mejor caso, más lento, y en algunas arquitecturas, un fallo.
Prácticamente todo el mundo la cumple. Fallan zipalign -c 4 solo 11 piezas de más de 15.000, y
ninguna de Google Play. Las entradas desalineadas suelen ser imágenes .png y resources.arsc.
Un ejemplo es dudeofx.eval (F-Droid, versión 102): su resources.arsc va sin comprimir, con los
datos en resto 1 módulo 4, y targetSdk 36.
Desde targetSdkVersion 30 esto dejó de ser una optimización para convertirse en requisito de
instalación:
«Apps that target Android 11 (API level 30) or higher can't be installed if they contain a compressed
resources.arscfile or if this file is not aligned on a 4-byte boundary.»
Si no se cumple, la plataforma responde con INSTALL_PARSE_FAILED_RESOURCES_ARSC_COMPRESSED.
De las apps con ese target, solo hemos encontrado una que no la cumpla: el propio
dudeofx.eval. No lo hemos instalado, así que no sabemos qué hace Android con él; solo sabemos
lo que hay en los bytes.
Veamos un caso concreto, medido sobre org.fossify.math (F-Droid, versión 1.4.0), entrada
assets/dexopt/baseline.prof:
LFH = 325 file_name_length = 27 extra_field_length (LFH) = 2 → datos en 384
325 + 30 + 27 + 2 = 384 = 4 × 96
Dos bytes de relleno, los mínimos para llegar al siguiente múltiplo de 4. Y la entrada
correspondiente del Central Directory declara extra field length = 0: el relleno de ceros
está solo en el Local File Header. Por esa asimetría zipinfo no lo enseña (los registros
0xd935, en cambio, a veces sí aparecen en el Central Directory, «sección 1.1 · Dos formas de rellenar»). Puedes
repetirlo con python3 -I scripts/muestrario/cifras/alineacion_y_16k_2.py lfh <apk> assets/dexopt/baseline.prof.
2.1 resources.arsc con target menor de 30
Por debajo de 30 la regla no es obligatoria, y ahí sí aparecen incumplimientos, aunque pocos:
menos del 1 % de las apps de F-Droid con ese target. Dos ejemplos son com.chessclock.android
y nl.asymmetrics.droidshows. Cabría esperar más casos en el mercado chino, pero allí casi no
hemos encontrado apps con un target tan bajo.
2.2 Qué va sin comprimir en un APK real
Para saber a qué afecta zipalign 4 conviene saber qué va sin comprimir. Casi siempre,
resources.arsc (prácticamente en el 100 % de los casos), las imágenes .png (más del 90 %) y
baseline.prof (entre el 70 % y el 90 %).
Los classes.dex van sin comprimir sobre todo cuando el minSdk es 28 o más: entonces es lo
habitual (entre el 90 % y el 98 % de las apps). Por debajo de 28 depende mucho de la fuente: en
F-Droid casi nunca, en Google Play aproximadamente la mitad de las veces.
Las .so de lib/<abi>/ van sin comprimir en unas dos de cada tres apps que las llevan, salvo en
el mercado chino, donde es raro (4 de 100).
3. La regla de las páginas de 16 KiB
3.1 Qué es
Para mapear una .so sin comprimir en un dispositivo con páginas de 16 KiB hacen falta dos
alineaciones distintas que se confunden a menudo: la del offset de sus datos dentro del APK y
la de los segmentos LOAD del propio ELF. Las dos, y lo que pasa cuando falla cada una, están en
la «sección 6.1 de Código nativo y ELF · Qué es el requisito».
Lo que importa aquí es que zipalign solo comprueba la primera, y además lo hace por el nombre:
aplica -P a toda entrada stored que acabe en .so, esté o no en lib/<abi>/, y nunca abre
el ELF (getAlignment y verify en ZipAlign.cpp). De ahí sale algo que conviene tener muy
claro: un APK puede pasar zipalign -c -P 16 y seguir siendo incompatible con páginas de
16 KiB, si sus .so tienen segmentos LOAD alineados a 2**12. Hacen falta los dos controles;
ninguno basta por sí solo.
Las dos cosas se ven en APK reales.
zipalign mira el nombre, no la carpeta. Es raro encontrar .so fuera de lib/<abi>/,
salvo en el mercado chino, donde aparecen en una de cada cuatro piezas. Casi siempre están en
assets/, porque los protectores como Jiagu 360 guardan ahí sus bibliotecas. Hemos visto APK que
fallan zipalign -c -P 16 4 únicamente por eso. Por ejemplo, com.jzzs.ParentsHelper (tienda
360): su única .so sin comprimir es assets/libjiagu.so, en un offset con resto 12.288 módulo
16.384, y las otras 14 van comprimidas. Pasa -c 4 y falla -c -P 16 4 solo por esa entrada. Algo
parecido le pasa a com.ss.android.ugc.aweme (Douyin) con assets/arm64-v8a/libalog.so.
Pasar zipalign no basta. Entre los APK que pasan zipalign -c -P 16 4 y llevan una .so de
64 bits, entre el 5 % y el 18 % (según la fuente) tienen algún segmento LOAD por debajo de
16 KiB, y en el mercado chino son tres de cada cuatro. Un ejemplo claro es el split de
arquitectura de net.bat.store (split_config.arm64_v8a.apk, descargado de APKMirror): sus 16
.so sin comprimir están todas en múltiplos de 16.384, pero 7 de ellas se enlazaron con
p_align de 4.096 (libcrashlytics-common, -handler, -trampoline, libcrashlytics,
libhpatchz, libmmkv y libsqlcipher). Pasa zipalign y aun así no puedes decir que sea
compatible. Ojo: la medida mira el segmento LOAD mínimo de cada .so; no tiene en cuenta el
RELRO ni el solape de segmentos que revisa el cargador.
3.2 Desde cuándo y a qué afecta
La regla de Google Play (targetSdkVersion 35 o superior, en dispositivos de 64 bits) y sus
fechas, que por cierto no coinciden entre el blog de Android Developers y la guía, están en la
«sección 6.2 de Código nativo y ELF · Fecha y alcance en Google Play». Es una regla de
publicación, no de la plataforma.
Del contenedor, el instalador solo mira el offset de una .so sin comprimir cuando la app declara
extractNativeLibs=false. En un dispositivo de 16 KiB, el Android 15 original rechaza el APK si
ese offset no es múltiplo de 16 KiB, con INSTALL_FAILED_INVALID_APK y «Library '…' is not
PAGE(16384)-aligned - will not be able to open it directly from apk» (NativeLibraryHelper.cpp).
Android 16 —y 15 desde QPR2, según el código— es más tolerante: si el offset es al menos múltiplo
de 4 KiB, extrae la biblioteca a disco en vez de rechazar el APK y lo marca con
pageSizeCompat=2. Puedes impedirlo con android:pageSizeCompat="disabled" en el manifiesto o
poniendo la propiedad pm.16kb.app_compat.disabled a true. La matriz ejecutada en Android 15 y
16 está en la «sección 6.4 de Código nativo y ELF · Qué pasa en el dispositivo».
Lo que vemos en los bytes de APK reales (no lo que hace Android al instalarlos):
- El atributo y el contenido casan siempre. No hemos encontrado ni una app con
extractNativeLibs=falseque lleve una.socomprimida, cosa que Android no instalaría. - Lo habitual es
falsecon todas las.sosin comprimir, en torno a dos de cada tres apps. El mercado chino es la excepción: allí casi nadie lo hace. trueexplícito es frecuente en Google Play (cerca del 40 %) y en el mercado chino (59 de 100). Algunas de esas apps llevan de todos modos alguna.sosin comprimir, yzipalign -P 16sí la comprueba.- Sin el atributo, alrededor del 10 % en F-Droid y bastantes más en el mercado chino. Con
minSdkmenor de 23, casi todas esas apps llevan las.socomprimidas. extractNativeLibs=falsecon.soen múltiplo de 4.096 pero no de 16.384, que es el caso que Android 16 resuelve extrayendo con aviso: entre el 3 % y el 15 % de las apps según la fuente.extractNativeLibs=falsecon una.soque ni siquiera es múltiplo de 4.096, el caso de rechazo: no hemos encontrado ninguna.
3.3 El comando
«If your APK contains shared libraries (
.sofiles), use-P 16to ensure that they're aligned to a 16KiB page boundary suitable formmap(2)in both 16KiB and 4KiB devices.»
-P generaliza el antiguo -p, que fijaba 4 KiB, aunque no lo retira. Así lo describe la ayuda
de zipalign 37.0.0:
Usage: zipalign [-f] [-p] [-P <pagesize_kb>] [-v] [-z] <align> infile.zip outfile.zip
zipalign -c [-p] [-P <pagesize_kb>] [-v] <align> infile.zip
…
-p: 4kb page-align uncompressed .so files
…
-P <pagesize_kb>: Align uncompressed .so files to the specified
page size. Valid values for <pagesize_kb> are 4, 16
and 64. '-P' cannot be used in combination with '-p'.
Dos detalles que despistan. El 4 del final sigue siendo obligatorio: es la alineación general
de la «sección 2 · La alineación de 4 bytes», y -P 16 solo añade una regla más estricta para las .so sin comprimir. Y
el valor de -P va en KiB, no en bytes: -P 16 significa 16.384.
El paso siguiente, firmar, también alinea. apksigner sign con sus valores por defecto
(--alignment-preserved false y --lib-page-alignment 16384) rehace el relleno de cada entrada
stored: 4 bytes para todas y 16 KiB para las que acaban en .so. Lo hemos medido con
build-tools 37.0.0: una .so que estaba en el offset 4.096 sale de apksigner en el 16.384, y
el resultado pasa zipalign -c -P 16 4. Con --alignment-preserved true se queda en el 4.096 y no
pasa. En apksig funciona así en las etiquetas android-15.0.0_r1, android-16.0.0_r1 y
android-17.0.0_r1; en android-14.0.0_r1 solo conservaba la alineación que traía la entrada.
En los APK reales se ve el rastro de este comportamiento: cuando un APK lleva el registro 0xd935
con valor 16.384, sus .so sin comprimir están todas en múltiplo de 16.384 (salvo un caso entre
200). Un ejemplo es el propio cliente de F-Droid (org.fdroid.fdroid, targetSdk 37), con cuatro
libandroidx.graphics.path.so sin comprimir y p_align de 16.384.
Pero no es lo común. La gran mayoría de APK con .so sin comprimir llevan relleno de ceros y
ningún 0xd935, y aun así cumplen los 16 KiB. Los registros con valor 4.096 apuntan a un
apksigner anterior a la regla de 16 KiB, aunque no podemos saber cuál.
3.4 Protectores y marcos
Los protectores comerciales suelen dejar sus bibliotecas fuera de lib/. Los motores conocidos
(Flutter, Unity, React Native), en cambio, van casi al día.
Protectores. En Google Play, todas las apps con protector que hemos visto (PairIP incluido)
tienen sus .so con p_align de 16.384 o más. En el mercado chino la cosa cambia: solo cumplen
11 de 34. Los que fallan son sobre todo Bangcle/SecNeo (libDexHelper.so, con p_align 4.096) y
algunos Ijiami; Jiagu 360 usa 65.536. Con tan pocas apps, tómalo como un recuento, no como una
tasa de «los protectores chinos». Tres ejemplos:
com.xtc.watch(tienda 360, Bangcle/SecNeo):lib/arm64-v8a/libDexHelper-x86.soconp_align4.096. No cumple.com.able.wisdomtree(mercado chino, Jiagu 360):assets/libjiagu_a64.soconp_align65.536.com.pazugames.avatarworld(Google Play, PairIP), splitsplit_config.arm64_v8a.apk:libpairipcore.soconp_align16.384.
Marcos. Entre las apps con .so en lib/arm64-v8a/ y targetSdk 35 o más, cumplen los
16 KB (segmentos LOAD con p_align de 16.384 o más y, si las .so se cargan desde el APK,
offsets del ZIP en múltiplo de 16.384):
| Marco | F-Droid | IzzyOnDroid | Google Play, más instaladas | Google Play, sorteo |
|---|---|---|---|---|
| Flutter | 352/368 (96 %) | 92/99 (93 %) | 26/27 (96 %) | 57/61 (93 %) |
| Unity | — | — | 89/91 (98 %) | 74/77 (96 %) |
| React Native | 57/67 (85 %) | — | 43/43 (100 %) | 29/32 (91 %) |
| Ninguno de esos | 1.565/1.674 (93 %) | 486/519 (94 %) | 309/345 (90 %) | 94/104 (90 %) |
Lo curioso es que, en Google Play, las que menos cumplen son las apps que no usan ninguno de esos
marcos, es decir, las que llevan código nativo propio. En F-Droid la cifra más baja es la de React
Native. Y si quitas el límite de targetSdk, la cosa baja bastante: cumplen el 79 % de las apps
Flutter de F-Droid y el 68 % de las de React Native.
3.5 Y las páginas de 64 KiB
zipalign admite también -P 64, pero casi nadie lo usa. Pocas apps tienen todas sus .so de
64 bits enlazadas a 64 KiB (entre el 1 % y el 6 %), y en el ZIP las .so sin comprimir caen en
múltiplo de 65.536 más o menos una de cada cuatro veces. Es justo lo que esperarías por azar de un
offset que ya está en múltiplo de 16.384. Dicho de otro modo: nadie alinea el ZIP a 64 KiB. Qué
haría -P 64 en un dispositivo de 64 KiB no lo hemos medido.
No confundas esto con las apps que tienen todos los segmentos LOAD a 64 KiB o más, que son
bastantes más (una de cada cinco en F-Droid), sobre todo por libflutter.so y libapp.so. Es
otra cifra.
4. El orden importa: alinear ANTES de firmar
Esta regla se rompe con facilidad: si pasas zipalign después de firmar, eliminas la firma v2 y
v3 sin que nadie te avise. La documentación oficial lo dice así:
«Caution: If you sign your APK using
apksignerand make further changes to the APK, the APK's signature is invalidated. If you usezipalignto align your APK, use it before signing the APK.»
4.1 Por qué exactamente
Hay dos motivos, uno detrás del otro, y los dos vienen de lo mismo: v2 firma bytes, no entradas.
- Alinear mueve bytes. El relleno del
extra fielddesplaza los datos de esa entrada y, con ellos, todo lo que va detrás: el resto de entradas, elCentral Directoryy elEOCD. El digest de v2 se calcula sobre el tramo 1 (del offset 0 al inicio delAPK Signing Block), elCentral Directoryy elEOCD(«sección 6.1 de APK Signing Block · Qué se trocea»). Cambiar el offset de cualquier entrada cambia el digest. zipalignreconstruye elZIPy por el camino tira elAPK Signing Block. No intenta conservarlo: copia entrada a entrada a un fichero nuevo y escribe unCentral Directoryy unEOCDnuevos. El hueco entre los datos y elCentral Directory, sencillamente, no se reproduce.
Por el segundo motivo, el primero ni llega a notarse: la firma no queda inválida, desaparece.
Y aquí entra la protección contra el downgrade de la «sección 5.2 de
Firma v4 y verificación · Las reglas, en orden». El .SF de v1 sí sobrevive, porque es
una entrada normal del ZIP, y en su cabecera X-Android-APK-Signed declara con qué esquemas se
firmó el APK. El verificador lee esa declaración, no encuentra los bloques y rechaza el fichero
acusándolo de manipulación.
El mensaje depende de lo que declare el .SF. Si dice X-Android-APK-Signed: 2, 3, apksigner
se queja de que faltan v2 y v3 («Signature stripped?»); si solo dice 2, el mensaje habla solo de
v2. Casi todos los APK con firma v1 declaran v2 o v3, así que este es el caso que te vas a
encontrar. La excepción son los APK firmados únicamente con v1: a esos, alinear después de firmar
no les rompe nada. Y si el APK no lleva v1, el mensaje es otro: «Missing META-INF/MANIFEST.MF».
Ese mismo error lo da apksigner verify en algunos splits de Google Play que no declaran minSdk
y que por eso se verifican exigiendo v1.
4.2 La demostración
Partimos de org.fossify.math (F-Droid, versión 1.4.0). Ya viene firmada con v2 y alineada. Esto
es lo que hay en ella, sin tocar nada:
- Mide 7.047.681 bytes. La última entrada acaba en 6.928.720.
- El
APK Signing Blockmide 4.096 bytes y empieza en 6.928.720, que no es múltiplo de 4.096 (6.928.720 = 4.096 × 1.691 + 2.384). Lleva el bloque de v2 (1.386 bytes) y un relleno0x42726577(2.654 bytes). No hay ceros delante del bloque. - El
Central Directoryempieza en 6.932.816 y elEOCD, en 7.047.659. - No tiene firma v1 (ningún
.SF) ni v3. - Las cuatro
libandroidx.graphics.path.sosin comprimir (una por ABI) están en 2.228.224, 2.244.608, 2.260.992 y 2.277.376, todas múltiplos de 16.384, y la app declaraextractNativeLibs=false. Por eso-P 16no mueve nada en esta pieza.
La receta, siempre sobre una copia:
BT=~/Library/Android/sdk/build-tools/37.0.0
SCR=/tmp/scratch/firma
cp org.fossify.math_10.apk $SCR/copia.apk
$BT/zipalign -c -v 4 $SCR/copia.apk | tail -2
$BT/zipalign -f -P 16 4 $SCR/copia.apk $SCR/copia_alineada.apk
ls -la $SCR/copia.apk $SCR/copia_alineada.apk
$BT/apksigner verify --verbose $SCR/copia_alineada.apk
Lo que esperamos (no lo hemos ejecutado sobre esta pieza): que zipalign devuelva 0, porque para
él todo ha ido bien; que la copia alineada mida 7.043.585 bytes, es decir, los 7.047.681 originales
menos los 4.096 del bloque que desaparece, ya que no hay nada más que mover; y que
apksigner verify falle con algo como «Missing META-INF/MANIFEST.MF», porque la pieza no lleva v1.
Los registros 0xd935 no cambian nada: zipalign los conserva y, como las entradas ya están
alineadas, no añade ceros («sección 1.1 · Dos formas de rellenar»). Lo comprobamos con un APK de prueba firmado con
apksigner 37.0.0 y pasado después por zipalign -f -P 16 4: los dos ficheros eran idénticos
hasta el inicio del Central Directory del segundo, registro 0xd935 de resources.arsc
incluido. Lo único distinto era el bloque y los ceros que lo precedían (fuente 10).
Para ver el mensaje «Signature stripped?» necesitas una copia firmada con v1+v2+v3 con una clave
de pruebas, como en la «sección 10.2 de Firma v4 y verificación · Firmar una copia y verificarla»,
porque solo entonces el .SF declara v2 y v3. Con esa copia, en una ejecución del 12 de agosto de
2026, la salida fue:
DOES NOT VERIFY
ERROR: JAR signer PRUEBAS.RSA: JAR signature META-INF/PRUEBAS.SF indicates the APK is signed
using APK Signature Scheme v2 but no such signature was found. Signature stripped?
ERROR: JAR signer PRUEBAS.RSA: JAR signature META-INF/PRUEBAS.SF indicates the APK is signed
using APK Signature Scheme v3 but no such signature was found. Signature stripped?
El mensaje engaña sobre la causa. «Signature stripped?» suena a ataque, y aquí no es más que
un zipalign ejecutado un paso tarde.
Un apunte de paso: los ceros que apksigner pone delante del bloque para que empiece en múltiplo
de 4.096 («sección 8 de APK Signing Block · El bloque de relleno») no los lleva todo el mundo.
Casi todos los APK de Google Play sí; en F-Droid, unos dos de cada tres, y en IzzyOnDroid, menos
de uno de cada cinco. El volcador de la «sección 9 de APK Signing Block · El volcador»
te enseña el bloque de cualquier APK.
4.3 El orden correcto
$BT/zipalign -f -P 16 4 $SCR/copia.apk $SCR/alineado.apk
$BT/apksigner sign --ks $SCR/pruebas.jks --ks-key-alias pruebas \
--ks-pass pass:pruebas --key-pass pass:pruebas \
--out $SCR/alineado_firmado.apk $SCR/alineado.apk
$BT/apksigner verify --verbose $SCR/alineado_firmado.apk | head -4
$BT/zipalign -c -v 4 $SCR/alineado_firmado.apk | tail -1
$BT/zipalign -c -P 16 4 $SCR/alineado_firmado.apk; echo "exit=$?"
Verifies
Verified using v1 scheme (JAR signing): false
Verified using v2 scheme (APK Signature Scheme v2): true
Verified using v3 scheme (APK Signature Scheme v3): true
Verification successful
exit=0
Alineado y luego firmado, las dos comprobaciones pasan. Esta salida es de una copia de prueba
firmada con las mismas opciones, no de la pieza de la «sección 4.2 · La demostración». Si quieres afirmar que la
cadena es determinista, comparar tamaños no basta: compara los SHA-256 de alineado_firmado.apk
y de la copia firmada sin zipalign previo.
La regla práctica: zipalign es lo último antes de firmar, y apksigner sign es lo último
de todo. Después, nada toca el APK.
¿Sigue haciendo falta zipalign? Para alinear, no, si firmas con apksigner sign de
build-tools 36.0.0 o posterior con sus valores por defecto: ya rehace el relleno de cada entrada
stored («sección 3.3 · El comando»). Sí lo necesitas:
- si firmas con otra herramienta que no realinee;
- si firmas con
--alignment-preserved true, que conserva la alineación de entrada; - para recomprimir con Zopfli (
-z), queapksignerno hace, y siempre antes de firmar; - como comprobación:
zipalign -cno modifica el fichero, y es el único uso dezipalignque puede ir después de firmar.
4.4 Bloques de canal
Las herramientas de canal chinas (Walle, VasDolly) añaden un par más al APK Signing Block
después de firmar, con los identificadores 0x71777777 (Walle) y 0x881155ff (VasDolly). No
rompen la firma v2 porque el bloque no entra en el digest, que cubre las entradas, el
Central Directory y el EOCD. Y como tampoco tocan las entradas, la alineación no cambia.
Es algo muy del mercado chino: lo hemos visto en 31 de 100 APK de allí (24 con Walle y 7 con
VasDolly) y en uno solo de Google Play. Todos pasan zipalign -c 4. Lo que sí varía es el tamaño
del bloque, que en algunos casos deja de ser múltiplo de 4.096. Y llevar el par de relleno
0x42726577 no significa que el APK se haya firmado con verity. Dos ejemplos con varios pares en
el bloque son com.tuniu.app.ui (0x7109871a, 0xf05368c0, 0x71777777 y 0x42726577) y
com.callme.sy (0x7109871a, 0x71777777 y 0x42726577).
5. zipalign -c como verificador
-c comprueba sin modificar. Devuelve 0 si todo cumple y 1 si algo no, así que puedes usarlo
en un script. Con -v imprime una línea por entrada con el offset de los datos, no el del
Local File Header.
| Comando | Qué comprueba | Qué reporta |
|---|---|---|
zipalign -c -v 4 |
Toda entrada stored en múltiplo de 4 |
(OK), (OK - compressed) o (BAD - <resto>) |
zipalign -c -P 16 -v 4 |
Lo anterior más las .so stored en múltiplo de 16.384 |
Ídem |
El (BAD - n) no es un código de error: es el resto de dividir el offset entre la alineación
exigida, o sea, cuántos bytes sobran.
5.1 Un caso que no cumple
Pasamos zipalign -c 4 y zipalign -c -P 16 4 (build-tools 37.0.0) por los más de 15.000 APK
del muestrario, incluidos los que van dentro de .apkm y .xapk. Ojo con los .apkm: dentro
las piezas van comprimidas, así que hay que extraerlas antes de comprobarlas.
zipalign -c -P 16 4 falla si alguna entrada stored no está en múltiplo de 4, o si alguna .so
sin comprimir (esté o no en lib/) no está en múltiplo de 16.384. Fallan 192 piezas de unas
15.000, y casi todas (181) pasan -c 4: el problema es la regla de 16 KiB, no la de 4 bytes. Y no
fallan solo los APK raros; fallan APK sueltos y splits de arquitectura:
- APK sueltos: el 1,6 % en F-Droid, el 8 % de los de Google Play descargados sueltos y el 19 %
en el mercado chino. Un ejemplo de F-Droid que pasa
-c 4y falla-c -P 16 4estk.hack5.treblecheck. - Splits de arquitectura: en torno al 2 % de los de APKMirror y al 9 % de los sacados con
adbde un móvil. Dos ejemplos son lossplit_config.arm64_v8a.apkdecakepop.gamesycom.huoyugame.ryz. - Bases y demás splits (idioma, densidad, módulos): ninguno.
Por qué fallan los splits de arquitectura de Google Play no lo sabemos, así que no lo afirmamos.
Tampoco hemos podido reproducir el fallo de Netflix que aparecía en otras muestras: el APK de
Netflix que tenemos es un universal de APKMirror y pasa -P 16.
Un caso concreto, con -v: el split de arquitectura de Photomath
(com.microblink.photomath 8.48.0, split_config.arm64_v8a.apk, del .apkm de APKMirror):
$BT/zipalign -c -P 16 -v 4 split_config.arm64_v8a.apk
Verifying alignment of split_config.arm64_v8a.apk (4)...
49 AndroidManifest.xml (OK - compressed)
4096 lib/arm64-v8a/libcrashlytics-common.so (BAD - 4096)
761856 lib/arm64-v8a/libcrashlytics-handler.so (BAD - 8192)
950272 lib/arm64-v8a/libcrashlytics-trampoline.so (OK)
962560 lib/arm64-v8a/libcrashlytics.so (BAD - 12288)
1159168 lib/arm64-v8a/libimage_processing_util_jni.so (BAD - 12288)
1188159 stamp-cert-sha256 (OK - compressed)
1188244 META-INF/BNDLTOOL.SF (OK - compressed)
1188702 META-INF/BNDLTOOL.RSA (OK - compressed)
1189847 META-INF/MANIFEST.MF (OK - compressed)
Verification FAILED
Código de salida: 1. Con la alineación general de 4 bytes, esas mismas entradas dan (OK) y
código de salida 0: mismas entradas, veredictos opuestos. El split está alineado a 4 KiB (la
primera .so empieza justo en 4096), así que cumple la regla vieja; lo que no cumple es la nueva
de 16 KiB. Con qué herramienta se construyó no lo podemos saber.
Si lees los offsets directamente del ZIP, ves de dónde salen los (BAD - n):
| Entrada | Offset de datos | mód 4096 | mód 16384 |
|---|---|---|---|
libcrashlytics-common.so |
4.096 | 0 | 4.096 |
libcrashlytics-handler.so |
761.856 | 0 | 8.192 |
libcrashlytics-trampoline.so |
950.272 | 0 | 0 |
libcrashlytics.so |
962.560 | 0 | 12.288 |
libimage_processing_util_jni.so |
1.159.168 | 0 | 12.288 |
El número entre paréntesis del (BAD - n) es exactamente la última columna. Puedes sacar la
tabla con python3 -I scripts/muestrario/cifras/alineacion_y_16k_1.py --offsets <apk> lib/.
Photomath no es un caso aislado. Casi todos los APK que fallan -P 16 por sus .so las tienen en
múltiplo de 4.096: cumplen la regla vieja. Y en Google Play, la mitad de ellos tienen además sus
ELF de 64 bits con p_align de 16.384 o más, así que les bastaría con realinear el ZIP. La otra
mitad tendría que volver a enlazar sus bibliotecas.
5.2 La trampa de interpretar el resultado
Termux (com.termux, versión 0.119.0-beta.3, de F-Droid) también da Verification successful
con -P 16. Y no es porque cumpla la regla de 16 KiB, sino porque no tiene ninguna entrada a la
que se le aplique: sus 12 .so van comprimidas y declara extractNativeLibs=true. Las tres de
arm64-v8a (liblocal-socket, libtermux-bootstrap y libtermux) tienen p_align de 4.096.
Las dos últimas líneas de la salida:
114835355 META-INF/84D3000E.RSA (OK - compressed)
114836484 META-INF/MANIFEST.MF (OK - compressed)
Verification successful
zipalign -c no responde a «¿cumple este APK la regla de 16 KiB?». Responde a «¿están alineadas
las entradas que debían estarlo?». No es lo mismo, y la segunda pregunta es más débil. Un APK
con todas las .so comprimidas pasa siempre, porque no tiene ninguna sin comprimir, y aun así
puede ser incompatible con dispositivos de 16 KiB por la alineación de sus segmentos ELF
(«sección 3.1 · Qué es»). Y no es raro: entre las apps con las .so de arm64-v8a comprimidas, más de un
tercio de las de F-Droid tienen algún segmento por debajo de 16 KiB, y en el mercado chino, casi
todas. Dos ejemplos que pasan zipalign -c -P 16 4 sin cumplir son org.sipdroid.sipua y
org.vi_server.androidudpbus.
Tampoco te fíes de extractNativeLibs=true. Lo que manda es el método de cada entrada, no el
atributo, y hay apps que lo declaran y aun así llevan alguna .so sin comprimir, que
zipalign -P 16 sí comprueba.
5.3 Dónde se rompe la regla en la práctica
La regla de 16 KiB se rompe casi siempre en el mismo sitio: los splits de arquitectura de Google
Play y los APK sueltos de otras fuentes. Esta tabla da, por tipo de pieza y fuente, cuántas fallan
zipalign -c -P 16 4. Fíjate en las filas de «APK suelto» y «split de arquitectura»: en las demás
no falla ninguna.
| Tipo de pieza | F-Droid | IzzyOnDroid | Google Play, más instaladas | Google Play, sorteo | Mercado chino |
|---|---|---|---|---|---|
| APK suelto | 75/4.766 (1,6 %) | 31/1.402 (2,2 %) | 16/202 (7,9 %) | — | 19/100 (19,0 %) |
base de un .apkm o de una carpeta de adb |
— | — | 0/386 | 0/315 | — |
| otros splits (idioma, densidad, módulos) | — | — | 0/5.938 | 0/578 | — |
| split de arquitectura | — | — | 22/962 (2,3 %) | 25/282 (8,9 %) | — |
APK único de adb |
— | — | — | 6/50 (12,0 %) | — |
Qué herramienta de empaquetado deja cada resultado no lo medimos, aunque la mayoría de los splits
de arquitectura los firmó bundletool (BNDLTOOL.SF). Con zipalign -c 4, en cambio, apenas
falla nada: 11 piezas, ninguna de Google Play.
Fuentes
- zipalign — Android Studio — https://developer.android.com/tools/zipalign
Consultado el 12 de agosto de 2026. De aquí salen la recomendación de
-P 16de la «sección 3.3 · El comando» y la advertencia sobre el orden respecto aapksignerde la «sección 4 · El orden importa: alinear ANTES de firmar». - Support 16 KB page sizes — Android Developers — https://developer.android.com/guide/practices/page-sizes
Consultado el 18 de octubre de 2026; la página se actualizó el 16 de octubre. De aquí salen
el umbral de
targetSdkVersion35 en dispositivos de 64 bits que resume la «sección 3.2 · Desde cuándo y a qué afecta» y el comandozipalign -c -P 16 -v 4de las secciones «3» y «5». - Behavior changes: Apps targeting Android 11 — Compressed resource files — https://developer.android.com/about/versions/11/behavior-changes-11
Consultado el 12 de agosto de 2026. De aquí sale la obligación de que
resources.arscvaya sin comprimir y alineado a 4 bytes, citada en la «sección 2 · La alineación de 4 bytes». - apksigner — Android Studio — https://developer.android.com/tools/apksigner
Consultado el 12 de agosto de 2026. De aquí sale la advertencia «If you use
zipalignto align your APK, use it before signing the APK» de la «sección 4 · El orden importa: alinear ANTES de firmar». Consultada de nuevo el 18 de octubre, con fecha del 5 de marzo, no documenta--alignment-preservedni--lib-page-alignment: esos salen de la fuente 9. zipaligndebuild-tools37.0.0 — ejecutado el 12 de agosto de 2026, y su ayuda de nuevo el 18 de octubre. De aquí salen las líneas de la ayuda de la «sección 3.3 · El comando» y las salidas de las secciones «4.3» y «5.1». La salida de Photomath de la «sección 5.1 · Un caso que no cumple» se obtuvo con la misma versión sobre el muestrario de octubre de 2026 (fuente 11).- AOSP —
frameworks/base/core/jni/com_android_internal_content_NativeLibraryHelper.cppen las etiquetasandroid-15.0.0_r1yandroid-16.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 conINSTALL_FAILED_INVALID_APKde una.sosin comprimir no alineada a la página del dispositivo y el modo de compatibilidad de 16 KiB de Android 16 (copyFileIfChanged), de la «sección 3.2 · Desde cuándo y a qué afecta». - AOSP —
tools/apksig/.../ApkSigner.javaen la etiquetaandroid-17.0.0_r1— https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/main/java/com/android/apksig/ApkSigner.java Consultado el 18 de octubre de 2026. De aquí sale el registro de alineación de la «sección 1.1 · Dos formas de rellenar»:ALIGNMENT_ZIP_EXTRA_DATA_FIELD_HEADER_ID = 0xd935y su tamaño mínimo de 6 bytes (líneas 75-86), y cómo descarta el relleno anterior y escribe el suyo (líneas 870-907). - AOSP —
build/make/tools/zipalignen la etiquetaandroid-17.0.0_r1— https://android.googlesource.com/platform/build/+/refs/tags/android-17.0.0_r1/tools/zipalign/ZipFile.cpp yZipEntry.cppdel mismo directorio. Consultado el 18 de octubre de 2026. De aquí sale el relleno con ceros de la «sección 1.1 · Dos formas de rellenar», que se añade detrás delextra fieldque ya traía la entrada:ZipFile::alignEntry(líneas 501-519) yZipEntry::addPadding(líneas 198-227). apksigner sign -hdebuild-tools36.0.0, 36.1.0 y 37.0.0, y https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/apksigner/java/com/android/apksigner/ApkSignerTool.java — ejecutado y consultado el 18 de octubre de 2026. De aquí salen los valores por defecto de--alignment-preservedy--lib-page-alignment(ApkSignerTool.java, líneas 155-156 y 216-221), de las secciones «3.3» y «4.3», y queapksignerno tenga ninguna opción de recompresión, de la «sección 4.3 · El orden correcto».apksigner0.9,zipalignyaapt2debuild-tools37.0.0 — ejecutados el 18 de octubre de 2026 sobre unAPKde prueba sin código generado conaapt2, firmado conapksigner signy pasado después porzipalign -f -P 16 4. De aquí sale la comprobación de la «sección 4.2 · La demostración».- Muestrario de octubre de 2026 — descrito en «El muestrario»,
Las cifras de esta página salen de
scripts/muestrario/cifras/alineacion_y_16k_1.pyyalineacion_y_16k_2.py, conzipalign37.0.0 como referencia.